并发总结

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

这里要引入一个概念：除了CPU以外所有的执行环境，主要是寄存器的一些内容，就构成了进程的上下文环境。进程的上下文是进程执行的环境。当这个程序执行完了，或者分配给他的CPU时间片用完了，那它就要被切换出去，等待下一次CPU的临幸。在被切换出去做的主要工作就是保存程序上下文，因为这个是下次他被CPU临幸的运行环境，必须保存
---


进程的颗粒度太大，每次的执行都要进行进程上下文的切换。如果我们把进程比喻为一个运行在电脑上的软件，那么一个软件的执行不可能是一条逻辑执行的，必定有多个分支和多个程序段，就好比要实现程序A，实际分成 a，b，c等多个块组合而成。那么这里具体的执行就可能变成：

程序A得到CPU -> CPU加载上下文，开始执行程序A的a小段，然后执行A的b小段，然后再执行A的c小段，最后CPU保存A的上下文。

这里a，b，c的执行是共享了A进程的上下文，CPU在执行的时候仅仅切换线程的上下文，而没有进行进程上下文切换的。进程的上下文切换的时间开销是远远大于线程上下文时间的开销。这样就让CPU的有效使用率得到提高。这里的a，b，c就是线程，也就是说线程是共享了进程的上下文环境的更为细小的CPU时间段。线程主要共享的是进程的地址空间。

作者：zhonyong
链接：https://www.zhihu.com/question/25532384/answer/81152571
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1

处于running下的线程因为某些原因进行阻塞状态后，会释放掉抢占到的CPU时间片，并且不会直接进入ready，而需要等待引起阻塞的原因消除时才进入ready.进入ready还要重新抢CPU时间片，当抢到cpu时间片后会接着上次运行的代码继续运行，而不是重新运行

1
2
3
4
5

 
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)。直到调用notify/notifyAll或wait时间到，线程会进入锁池。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池（又称为同步队列）中。当锁池中的线程拿到对象的锁时会重新进入Ready转态
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁） 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class ThreadTest04 {
    public static void main(String[] args) {
//  获取当前线程对象，
//        这个代码出现在main方法中，所以当前线程就是主线程
        Thread currentthread=Thread.currentThread();
        System.out.println(currentthread.getName());


        MyThread01 myThread01=new MyThread01();
        Thread thread01=new Thread(myThread01);

//          设置线程名字
        thread01.setName("beijing");
//        获取线程名字
        System.out.println("分支线程名字为："+thread01.getName());

        Thread thread02=new Thread(myThread01);
        System.out.println(thread02.getName());
//        thread01.start();

    }
}

class MyThread01 implements Runnable{

    @Override
    public void run() {
        System.out.println("这是分支线程");
    }
}

/*
main
分支线程名字为：beijing
Thread-1
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class ThreadTest06 {
    public static void main(String[] args) throws InterruptedException {
        Mythread02 mythread02=new Mythread02();
        Thread thread=new Thread(mythread02);

//        thread.setName("t");

        thread.start();

        Thread.sleep(1000*5);//让当前线程进入睡眠，也就是main进入睡眠
        System.out.println(Thread.currentThread().getName());
        System.out.println("主线程");
    }
}

class Mythread02 implements Runnable{
    @Override
    public void run() {
//        让子线程进入睡眠
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class ThreadTest07 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(new MyThread03());
//        thread.setName("t");
        thread.start();

    //主线程睡眠5秒，但是分支线程还在执行，5秒后执行thread.interrupt();分支线程中断睡眠
        Thread.sleep(1000*5);

//        中断thread线程的睡眠，这种中断睡眠的方式依靠的是异常处理机制
        thread.interrupt();


    }

}

class MyThread03 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"  start");
        try {
            Thread.sleep(1000*60);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"  end");
    }
}
/*
Thread-0  start
java.lang.InterruptedException: sleep interrupted
	at java.base/java.lang.Thread.sleep(Native Method)
	at ThreadTest.MyThread03.run(ThreadTest07.java:37)
	at java.base/java.lang.Thread.run(Thread.java:832)
Thread-0  end
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class ThreadTest08 {
    public static void main(String[] args) throws InterruptedException {
        MyThread04 myThread04=new MyThread04();
        Thread thread=new Thread(myThread04);
        thread.start();

//        主线程睡眠5秒，但是分支线程还在执行,5秒后执行myThread04.run=false;此时分支线程结束
        Thread.sleep(1000*5);

        myThread04.run=false;
    }
}


class MyThread04 implements Runnable{
    boolean run=true;
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            if (run){
//                如果run=true，每隔一秒输出一次
                System.out.println(Thread.currentThread().getName()+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            else {
//                可以在return前将需要保存的数据进行保存
                return;//return表示方法结束
            }
        }
    }
}
/*
Thread-00
Thread-01
Thread-02
Thread-03
Thread-04

Process finished with exit code 0
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class ThreadTest09 {
    public static void main(String[] args) throws InterruptedException {
        Mythread009 mythread009=new Mythread009();
        Thread thread1=new Thread(mythread009);
        thread1.start();

         Thread.yield();//属于静态方法，使得running的线程让出cpu时间片

//        System.out.println("主线程开始");
        for (int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
//        System.out.println("主线程结束");

    }
}

class Mythread009 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class ThreadTest09 {
    public static void main(String[] args) throws InterruptedException {
        Mythread009 mythread009=new Mythread009();
        Thread thread1=new Thread(mythread009);
        thread1.start();
/*
* join()方法会将thread1合并到主线程中，直到thread1线程结束才开始执行主线程，两个栈之间发生了等待
* */
        thread1.join();

//        System.out.println("主线程开始");
        for (int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
//        System.out.println("主线程结束");

    }
}

class Mythread009 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}
/*
Thread-01
Thread-02
main0
main1
main2
*/

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

package ThreadTest;

import javax.print.attribute.standard.PrinterURI;
import java.util.ArrayList;
import java.util.List;

/**
 * ClassName:    ThreadTest11
 * Package:    ThreadTest
 * Description:
 * Datetime:    2020/10/18   下午4:21
 * Author:   shilongshen
 */
/*
 * 使用wait和notify方法实现生产者和消费者模式
 *“生产者和消费者模式”： 生成线程负责生产，消费线程负责消费，两者要保持均衡
 *
 * 模拟这样一个需求：
 *       用list集合表示一个仓库
 *       list集合中最多只能存一个元素
 *       一个元素表示仓库满了。0个元素表示仓库空了
 *       必须做到生产一个消费一个
 *
 * */
public class ThreadTest11 {
    public static void main(String[] args) {
//        创建一个仓库，共享的
        List list = new ArrayList();
//        创建生产者线程
        Thread t1 = new Thread(new Producer(list));
//        创建消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();


    }
}


//生产线程
class Producer implements Runnable {
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
//生产者一直进行生产，使用死循环进行模拟
        while (true) {
            synchronized (list) {//首先获取对象锁
                if (list.size() > 0) {//如果list中元素对象大于0(等于1),调用wait()方法，
                    // 使得当前线程进入等待状态，并释放获得的锁，释放掉锁之后，消费者线程进行消费
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果list中的元素等于0,往list中添加元素
                Boolean is=list.add("String");//消费者进入等待状态，释放锁，说明，list集合元素为0,
                // 此时会执行此处代码(而不会执行if语句内的代码)，将list集合中的元素进行增加
                System.out.println(Thread.currentThread().getName() + "--->" + "String");
                list.notify();//唤醒等待的消费者进程

            }
        }
    }
}

//消费线程
class Consumer implements Runnable {
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
//消费者模式一直进行消费
        while (true) {
            synchronized (list) {
                if (list.size() == 0) {//如果list中元素对象等于0,调用wait()方法，
                    // 使得当前线程进入等待状态，并释放获得的锁,释放掉锁之后，生产者线程进行生产
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                Object o = list.remove(0);//生产者进入等待状态，释放锁，说明，list集合元素为1,
                // 此时会执行此处代码(而不会执行if语句内的代码)，将list集合中的元素进行删除
                System.out.println(Thread.currentThread().getName() + "--->" + o);
                list.notify();//notify()为唤醒生产者线程(唤醒list对象上等待的线程)
            }
        }
    }
}

1
2
3
4
5
6

假设最开始是生产者线程抢到了对象锁和CPU时间片，此时list中元素为0，所以会添加一个元素，然后执行notify，尽管此时等待队列中没有线程，run方法结束，生产者线程释放cpu时间片和对象锁。
因为是一个循环语句所以此时处于ready的有生产者线程和消费者线程
1.如果还是生产者线程抢到cpu时间片和对象锁，由于list元素大于1,会调用list.wait()使得生产者线程释放锁，进入等待池。然后	必定是消费者线程执行，此时list元素不为0,所以会删除元素，然后调用list.notify()唤醒等待池中的生产者线程，使其进入锁池，因为锁池中只有生产者线程一个线程，所以生产者线程必定拿到对象锁进入ready。
	1.1. 此时ready的有生产者线程和消费者线程，
		1.1.1.如果是消费者拿到CPU时间片，但是由于没有对象锁，所以会释放CPU时间片进入锁池
		1.1.2 所以必定是这一次必定是生产者线程进行生产，此时，所以会添加一个元素，然后执行notify，尽管此时等待队列中没有线程， run方法结束，生产者线程释放cpu时间片和对象锁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class SyncCodeBlock {

   public int i;

   public void syncTask(){
       //同步代码库
       synchronized (this){
           i++;
       }
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncCodeBlock.class
  Last modified 2017-6-2; size 426 bytes
  MD5 checksum c80bc322c87b312de760942820b4fed5
  Compiled from "SyncCodeBlock.java"
public class com.zejian.concurrencys.SyncCodeBlock
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
  //........省略常量池中数据
  //构造函数
  public com.zejian.concurrencys.SyncCodeBlock();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 7: 0
  //===========主要看看syncTask方法实现================
  public void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter  //注意此处，进入同步方法
         4: aload_0
         5: dup
         6: getfield      #2             // Field i:I
         9: iconst_1
        10: iadd
        11: putfield      #2            // Field i:I
        14: aload_1
        15: monitorexit   //注意此处，退出同步方法
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit //注意此处，退出同步方法
        22: aload_2
        23: athrow
        24: return
      Exception table:
      //省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"

1
2
3
4
5
6

3: monitorenter  //进入同步方法
//..........省略其他  
15: monitorexit   //退出同步方法
16: goto          24
//省略其他.......
21: monitorexit //退出同步方法

1
2
3
4
5
6
7
8

public class SyncMethod {

   public int i;

   public synchronized void syncTask(){
           i++;
   }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncMethod.class
  Last modified 2017-6-2; size 308 bytes
  MD5 checksum f34075a8c059ea65e4cc2fa610e0cd94
  Compiled from "SyncMethod.java"
public class com.zejian.concurrencys.SyncMethod
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool;

   //省略没必要的字节码
  //==================syncTask方法======================
  public synchronized void syncTask();
    descriptor: ()V
    //方法标识ACC_PUBLIC代表public修饰，ACC_SYNCHRONIZED指明该方法为同步方法
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2                  // Field i:I
         5: iconst_1
         6: iadd
         7: putfield      #2                  // Field i:I
        10: return
      LineNumberTable:
        line 12: 0
        line 13: 10
}
SourceFile: "SyncMethod.java"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class AccountingSync implements Runnable{
    static AccountingSync instance=new AccountingSync();
    static int i=0;
    static int j=0;
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){

            //this,当前实例对象锁
            synchronized(this){
                i++;
                increase();//synchronized的可重入性
            }
        }
    }

    public synchronized void increase(){
        j++;
    }


    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}
————————————————
版权声明：本文为CSDN博主「zejian_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/javazejian/article/details/72828483

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package ThreadDeadLockTest01;

/**
 * ClassName:    DeadLockTest01
 * Package:    ThreadDeadLockTest01
 * Description:
 * Datetime:    2020/10/17   下午8:24
 * Author:   shilongshen
 */
/*
* 死锁
*怎么写死锁:
* 当t1线程锁住o1的锁时，由于t2线程已经锁住了o2对象的锁，所以t1线程永远不会结束，同理t2线程也不会结束。
*
* --->synchronized在开发中最好不要嵌套使用
* */
public class DeadLockTest01 {
    public static void main(String[] args) {
        Object o1=new Object();
        Object o2=new Object();
        //t1,t2线程共享o1,o2
        Thread t1=new Thread(new Mythread1(o1,o2));
        Thread t2=new Thread(new Mythread2(o1,o2));

        t1.setName("t1");
        t2.setName("t2");

        t1.start();
        t2.start();

    }
}

class Mythread1 implements Runnable{
    Object o1;
    Object o2;
    public Mythread1(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    @Override
    public void run() {
        synchronized(o1){
            System.out.println("t1 -->o1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
                System.out.println("t1-->o2");
            }
        }
    }
}


class Mythread2 implements Runnable{
    Object o1;
    Object o2;
    public Mythread2(Object o1,Object o2){
        this.o1=o1;
        this.o2=o2;
    }
    @Override
    public void run() {
        synchronized(o2){
            System.out.println("t2-->o2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
                System.out.println("t2--->o1");
            }
        }
    }
}

1
2
3
4
5
6
7

Lock lock = new ReentrantLock();
lock.lock();
try{
    //临界区......
}finally{
    lock.unlock();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public interface Lock {
    //加锁
    void lock();

    //解锁
    void unlock();

    //可中断获取锁，与lock()不同之处在于可响应中断操作，即在获
    //取锁的过程中可中断，注意synchronized在获取锁时是不可中断的
    void lockInterruptibly() throws InterruptedException;

    //尝试非阻塞获取锁，调用该方法后立即返回结果，如果能够获取则返回true，否则返回false
    boolean tryLock();

    //根据传入的时间段获取锁，在指定时间内没有获取锁则返回false，如果在指定时间内当前线程未被中并断获取到锁则返回true
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    //获取等待通知组件，该组件与当前锁绑定，当前线程只有获得了锁
    //才能调用该组件的wait()方法，而调用后，当前线程将释放锁。
    Condition newCondition();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package Test;

import java.util.concurrent.locks.ReentrantLock;

public class bean37 {
    public static void main(String[] args) throws InterruptedException {
        MyLock t1=new MyLock();
        MyLock t2=new MyLock();
        Thread thread1=new Thread(t1);
        Thread thread2=new Thread(t2);
        thread1.start();
        thread2.start();
        thread1.join();

    }
}

class MyLock implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            lock.lock();
            lock.lock();
            try {
                i++;
                System.out.print("当前线程:"+Thread.currentThread()+" i="+i);
                System.out.println();
            } finally {
                lock.unlock();
                lock.unlock();
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//查询当前线程保持此锁的次数。
int getHoldCount() 

//返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。      
protected  Thread   getOwner(); 

//返回一个 collection，它包含可能正等待获取此锁的线程，其内部维持一个队列，这点稍后会分析。      
protected  Collection<Thread>   getQueuedThreads(); 

//返回正等待获取此锁的线程估计数。   
int getQueueLength();

// 返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
protected  Collection<Thread>   getWaitingThreads(Condition condition); 

//返回等待与此锁相关的给定条件的线程估计数。       
int getWaitQueueLength(Condition condition);

// 查询给定线程是否正在等待获取此锁。     
boolean hasQueuedThread(Thread thread); 

//查询是否有些线程正在等待获取此锁。     
boolean hasQueuedThreads();

//查询是否有些线程正在等待与此锁有关的给定条件。     
boolean hasWaiters(Condition condition); 

//如果此锁的公平设置为 true，则返回 true。     
boolean isFair() 

//查询当前线程是否保持此锁。      
boolean isHeldByCurrentThread() 

//查询此锁是否由任意线程保持。        
boolean isLocked()       

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/**
 * AQS抽象类
 */
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer{
//指向同步队列队头
private transient volatile Node head;

//指向同步的队尾
private transient volatile Node tail;

//同步状态，0代表锁未被占用，1代表锁已被占用
private volatile int state;

//省略其他代码......
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

static final class Node {
    //共享模式
    static final Node SHARED = new Node();
    //独占模式
    static final Node EXCLUSIVE = null;

    //标识线程已处于结束状态
    static final int CANCELLED =  1;
    //等待被唤醒状态
    static final int SIGNAL    = -1;
    //条件状态，
    static final int CONDITION = -2;
    //在共享模式中使用表示获得的同步状态会被传播
    static final int PROPAGATE = -3;

    //等待状态,存在CANCELLED、SIGNAL、CONDITION、PROPAGATE 4种
    volatile int waitStatus;

    //同步队列中前驱结点
    volatile Node prev;

    //同步队列中后继结点
    volatile Node next;

    //请求锁的线程
    volatile Thread thread;

    //等待队列中的后继结点，这个与Condition有关，稍后会分析
    Node nextWaiter;

    //判断是否为共享模式
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    //获取前驱结点
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    //.....
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//AQS中提供的主要模板方法，由子类实现。
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer{

    //独占模式下获取锁的方法
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

    //独占模式下解锁的方法
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

    //共享模式下获取锁的方法
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

    //共享模式下解锁的方法
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
    //判断是否为持有独占锁
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

public class ThreadLocalTest {
    public static void main(String[] args) throws InterruptedException {
        ThreadLocal<String> threadLocal=new ThreadLocal<>();//创建一个ThreadLocal变量
        MyThread  myThread=new MyThread(threadLocal);
        Thread thread1=new Thread(myThread);
        thread1.setName("t1");


        threadLocal.set("beijing");//main进程调用了ThreadLocal，并设置为“beijing”，注意设置的是threadLocal在main线程的这个副本
        
        
        System.out.println(Thread.currentThread().getName()+" before ThreadLocal= "+threadLocal.get());

        thread1.start();
        Thread.sleep(1000*1);//使main进程睡眠1s，确保t1先执行

        System.out.println(Thread.currentThread().getName()+" after ThreadLocal= "+threadLocal.get());//输出为beijing,得到的是threadLocal在main线程的这个副本，t1线程中threadLocal副本的更改不会影响到main线程的副本。

    }
}

class  MyThread implements Runnable{
    ThreadLocal<String> local=new ThreadLocal<>();
    public MyThread(ThreadLocal<String> local ){
        this.local=local;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" before ThreadLocal= "+local.get());//得到的为null，注意得到的是threadLocal在t1线程的这个副本,初始值为null
        local.set("shenzhen");
        System.out.println(Thread.currentThread().getName()+" after ThreadLocal= "+local.get());
    }
}

/*
main before ThreadLocal= beijing
t1 before ThreadLocal= null
t1 after ThreadLocal= shenzhen
main after ThreadLocal= beijing
*/

1
2
3
4
5
6
7
8
9

public void set(T value) {
        Thread t = Thread.currentThread();//获取当前线程
        ThreadLocalMap map = getMap(t);//调用getMap获取ThreadLocalMap
        if (map != null) {//如果map存在，则将当前线程对象t作为key，要存储的对象作为value存到map里面去
            map.set(this, value);
        } else {//如果该Map不存在，则初始化一个。
            createMap(t, value);
        }
    }

1
2
3
4
5
6

public interface Runnable {
    /*
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class CallableTest01 {
    public static void main(String[] args) {
        MyThread01 myThread01=new MyThread01();
        /*
        创建一个线程需要通过 new Thread('Runnable')
        但是Thread内的参数应该为'Runnable'类型(Thread构造方法的参数类型为Runnable)
        我们通过Callable创建的对象为Callable,怎么办呢？
        这时我们可以通过Runnable下的一个实现类: FutureTask,来解决这一问题。
        FutureTask传入的参数类型为Callable类型(通过构造函数来包装Callable)
        再将FutureTask的对象作为Thread的参数
        
        */
        FutureTask futureTask=new FutureTask(myThread01);

        Thread thread01=new Thread(futureTask);
        thread01.setName("t1");
        thread01.start();
        System.out.println(futureTask.get());//可以得到call()方法的返回值

    }
}

class MyThread01 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+ " is running");
        return 1024;
    }
}
/*
t1 is running
1024
*/

1
2
3
4
5
6

    Callable规定的方法是call()，而Runnable规定的方法是run()
    Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
    call()方法可抛出异常，而run()方法是不能抛出异常的。
    运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 它提供了检查计算是否完成的方法，以等待计算的完成，并检索  计算的结果。
    通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
    Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

1

public class FutureTask<V> implements RunnableFuture<V>

1
2
3
4
5
6
7

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
 
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

1
2
3

Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
Future<T> submit(Runnable task,T result)

1
2

shutdown：被关闭的执行器不再接收新的任务，当所有任务执行完成后，线程池中的线程死亡
shutdownNow：立即取消所有尚未开始的任务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package ExecutorTest;

import java.util.concurrent.*;

/**
 * ClassName:    ExecutorTest
 * Package:    ExecutorTest
 * Description:
 * Datetime:    2020/11/30   上午11:12
 * Author:   shilongshen
 */
public class ExecutorTest {
    public static void main(String[] args) {
        ExecutorService executor= Executors.newCachedThreadPool();//Executors中的静态方法来创建线程池，返回类型为ExecutorService

        MyThread myThread=new MyThread();

        executor.submit(myThread);//通过submit提交Runnable对象

        executor.shutdown();//关闭线程

    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" is running");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class bean33 {
    public static void main(String[] args) {
        //通过构造方法来创建线程
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(1,2, 1000,
                        TimeUnit.MILLISECONDS,
                        new SynchronousQueue<Runnable>(),
                        Executors.defaultThreadFactory(),
                        new ThreadPoolExecutor.AbortPolicy());

        //通过Executors创建线程  -->通过预定义线程池创建
        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
        System.out.println(executorService.getCorePoolSize());

        ThreadPoolExecutor newCachedThreadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
    }
}

参考：https://www.jianshu.com/p/f030aa5d7a28

1
2

线程池中有特定数量的线程，当有任务到来时就会调用线程进行处理。
如果任务数量大于线程数量，多出来的任务就在等待队列中等待

1
2
3
4
5
6
7

*A*线程创建后，调用start()方法进入就绪状态

*B*线程创建后，调用run()方法进入就绪状态

*C*在同一Thread对象上不允许两次调用strat()方法  //同一Thread对象即同一线程，在线程的整个生命过程中，只会调用一次start()，多次启动线程是违法的

*D*线程调用stop()后进入终止状态