1
    public synchronized void start() {
2
        /**
3
         * This method is not invoked for the main method thread or "system"
4
         * group threads created/set up by the VM. Any new functionality added
5
         * to this method in the future may have to also be added to the VM.
6
         *
7
         * A zero status value corresponds to state "NEW".
8
         */
9
        if (threadStatus != 0)
10
            throw new IllegalThreadStateException();
11

12
        /* Notify the group that this thread is about to be started
13
         * so that it can be added to the group's list of threads
14
         * and the group's unstarted count can be decremented. */
15
        group.add(this);
16

17
        boolean started = false;
18
        try {
19
            start0();
20
            started = true;
21
        } finally {
22
            try {
23
                if (!started) {
24
                    group.threadStartFailed(this);
25
                }
26
            } catch (Throwable ignore) {
27
                /* do nothing. If start0 threw a Throwable then
28
                  it will be passed up the call stack */
29
            }
30
        }
31
    }
32
  //这是一个C++底层，Java是没有权限操作底层硬件的
33
    private native void start0();

1
public class Test1 {
2
    public static void main(String[] args) {
3
        //获取cpu的逻辑核心(线程)数量
4
        System.out.println(Runtime.getRuntime().availableProcessors());
5
    }
6
}

1
public enum State {
2

3
      //运行
4
        NEW,
5

6
      //运行
7
        RUNNABLE,
8

9
      //阻塞
10
        BLOCKED,
11

12
      //等待
13
        WAITING,
14

15
      //超时等待
16
        TIMED_WAITING,
17

18
      //终止
19
        TERMINATED;
20
    }

1
// java.util.concurrent.TimeUnit;
2
TimeUnit.DAYS.sleep(1); //休眠1天
3
TimeUnit.SECONDS.sleep(1); //休眠1s

1
package com.example.juc.demo01;
2

3
import java.util.concurrent.TimeUnit;
4

5
public class Test1 {
6
 public static void main(String[] args) throws InterruptedException {
7
    //获取逻辑核心（线程）
8

9
    System.out.println(Runtime.getRuntime().availableProcessors());
10
    Thread.sleep(1000);
11
    TimeUnit.SECONDS.sleep(1);
12

13
    Test1 test = new Test1();
14
    test.wait();
15
 }
16
}

1
package com.example.juc.demo01;
2

3
public class SaleTicket {
4
    public static void main(String[] args) {
5
        final Ticket ticket = new Ticket();
6
        // lamda 表达式开启新的线程
7
        new Thread(()->{
8
            for (int i = 0; i < 40; i++) {
9
                ticket.sale();
10
            }
11
        },"A").start();
12
        new Thread(()->{
13
            for (int i = 0; i < 40; i++) {
14
                ticket.sale();
15
            }
16
        },"B").start();
17
        new Thread(()->{
18
            for (int i = 0; i < 40; i++) {
19
                ticket.sale();
20
            }
21
        },"C").start();
22
    }
23
}
24
// 资源类 OOP 属性、方法
25
class Ticket {
26
    private int number = 30;
27

28
    //卖票的方式
29
    public synchronized void sale() {
30
        if (number > 0) {
31
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
32
        }
33
    }
34
}

1
package com.example.juc.demo01;
2

3
import java.util.concurrent.locks.Lock;
4
import java.util.concurrent.locks.ReentrantLock;
5

6
public class SaleTicket1 {
7
    public static void main(String[] args) {
8
        final Ticket1 ticket = new Ticket1();
9

10
        new Thread(()->{
11
            for (int i = 0; i < 40; i++) {
12
                ticket.sale();
13
            }
14
        },"A").start();
15
        new Thread(()->{
16
            for (int i = 0; i < 40; i++) {
17
                ticket.sale();
18
            }
19
        },"B").start();
20
        new Thread(()->{
21
            for (int i = 0; i < 40; i++) {
22
                ticket.sale();
23
            }
24
        },"C").start();
25
    }
26
}
27
// 1.获取锁
28
// 2.加锁
29
// 3.解锁
30
// 资源类 OOP 属性、方法
31
class Ticket1     {
32
    private int number = 30;
33
    Lock lock = new ReentrantLock();
34
    //卖票的方式
35
    public  void sale() {
36
        if (number > 0) {
37
            lock.lock(); // 加锁
38
            try {
39
                 System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
40
            } catch (Exception e) {
41
                e.printStackTrace();
42
            } finally {
43
                lock.unlock(); // 解锁
44
            }
45
        }
46
    }
47
}

1
package com.example.juc.pc;
2

3
public class A {
4
    public static void main(String[] args) {
5
        B b = new B();
6
        new Thread(() -> {
7
            for (int i = 0; i < 10; i++) {
8
                b.increment();
9
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
10
            }
11
        }, "A").start();
12
        new Thread(() -> {
13
            for (int i = 0; i < 10; i++) {
14
                b.decrement();
15
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
16
            }
17
        }, "B").start();
18
    }
19
}
20

21
class B {
22
    Integer num = 0;
23

24
    public synchronized void increment() {
25
        if (num != 0) {
26
            try {
27
                wait();
28
            } catch (InterruptedException e) {
29
                e.printStackTrace();
30
            }
31
        }
32
        num++;
33
        notifyAll();
34
    }
35

36
    public synchronized void decrement() {
37
        if (num == 0) {
38
            try {
39
                wait();
40
            } catch (InterruptedException e) {
41
                e.printStackTrace();
42
            }
43
        }
44
        num--;
45
        notifyAll();
46
    }
47
}

1
package com.example.juc.pc;
2

3
public class A {
4
    public static void main(String[] args) {
5
        B b = new B();
6
        new Thread(() -> {
7
            for (int i = 0; i < 10; i++) {
8
                b.increment();
9
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
10
            }
11
        }, "A").start();
12
        new Thread(() -> {
13
            for (int i = 0; i < 10; i++) {
14
                b.decrement();
15
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
16
            }
17
        }, "B").start();
18

19
        new Thread(() -> {
20
            for (int i = 0; i < 10; i++) {
21
                b.decrement();
22
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
23
            }
24
        }, "C").start();
25

26
        new Thread(() -> {
27
            for (int i = 0; i < 10; i++) {
28
                b.increment();
29
                System.out.println(Thread.currentThread().getName() + "-" + b.num);
30
            }
31
        }, "D").start();
32
    }
33
}
34

35
class B {
36
    Integer num = 0;
37

38
    public synchronized void increment() {
39
        if (num != 0) {
40
            try {
41
                wait();
42
            } catch (InterruptedException e) {
43
                e.printStackTrace();
44
            }
45
        }
46
        num++;
47
        notifyAll();
48
    }
49

50
    public synchronized void decrement() {
51
        while (num == 0) {
52
            try {
53
                wait();
54
            } catch (InterruptedException e) {
55
                e.printStackTrace();
56
            }
57
        }
58
        num--;
59
        notifyAll();
60
    }
61
}

1
package com.example.juc.pc;
2

3
import java.util.concurrent.locks.Condition;
4
import java.util.concurrent.locks.Lock;
5
import java.util.concurrent.locks.ReentrantLock;
6

7
public class B {
8
    public static void main(String[] args) {
9
        Data2 data = new Data2();
10
        new Thread(() -> {
11
            for (int i = 0; i < 10; i++) {
12
                try {
13
                    data.increment();
14
                } catch (InterruptedException e) {
15
                    e.printStackTrace();
16
                }
17
                System.out.println(Thread.currentThread().getName() + "-" + data.num);
18
            }
19
        }, "A").start();
20
        new Thread(() -> {
21
            for (int i = 0; i < 10; i++) {
22
                try {
23
                    data.decrement();
24
                } catch (InterruptedException e) {
25
                    e.printStackTrace();
26
                }
27
                System.out.println(Thread.currentThread().getName() + "-" + data.num);
28
            }
29
        }, "B").start();
30

31
        new Thread(() -> {
32
            for (int i = 0; i < 10; i++) {
33
                try {
34
                    data.increment();
35
                } catch (InterruptedException e) {
36
                    e.printStackTrace();
37
                }
38
                System.out.println(Thread.currentThread().getName() + "-" + data.num);
39
            }
40
        }, "C").start();
41

42
        new Thread(() -> {
43
            for (int i = 0; i < 10; i++) {
44
                try {
45
                    data.decrement();
46
                } catch (InterruptedException e) {
47
                    e.printStackTrace();
48
                }
49
                System.out.println(Thread.currentThread().getName() + "-" + data.num);
50
            }
51
        }, "D").start();
52
    }
53
}
54
// 判断等待，业务，通知
55
class Data2 {
56
    Integer num = 0;
57

58
    Lock lock = new ReentrantLock();
59

60
    Condition condition = lock.newCondition();
61

62
    public  void increment() throws InterruptedException {
63
        lock.lock();
64
        try {
65
            while (num != 0) {
66
                try {
67
                    condition.await();
68
                } catch (InterruptedException e) {
69
                    e.printStackTrace();
70
                }
71
            }
72
            num++;
73
            condition.signalAll();
74
        } catch (Exception e) {
75
            e.printStackTrace();
76
        } finally {
77
            lock.unlock();
78
        }
79
    }
80

81
    public void decrement() throws InterruptedException{
82
        lock.lock();
83
        try {
84
            while (num == 0) {
85
                try {
86
                    condition.await();
87
                } catch (InterruptedException e) {
88
                    e.printStackTrace();
89
                }
90
            }
91
            num--;
92
            condition.signalAll();
93
        } catch (Exception e) {
94
           e.printStackTrace();
95
        } finally {
96
            lock.unlock();
97
        }
98
    }
99
}

1
// A->B
2
// B->C
3
// C->A
4
// ...
5
package com.example.juc.pc;
6

7
import java.util.concurrent.locks.Condition;
8
import java.util.concurrent.locks.Lock;
9
import java.util.concurrent.locks.ReentrantLock;
10

11
public class C {
12
    public static void main(String[] args) {
13
        Data3 data = new Data3();
14
        new Thread(() -> {
15
            for (int i = 0; i < 10; i++) {
16
                try {
17
                    data.printA();
18
                } catch (InterruptedException e) {
19
                    e.printStackTrace();
20
                }
21
            }
22
        }, "A").start();
23
        new Thread(() -> {
24
            for (int i = 0; i < 10; i++) {
25
                try {
26
                    data.printB();
27
                } catch (InterruptedException e) {
28
                    e.printStackTrace();
29
                }
30
            }
31
        }, "B").start();
32

33
        new Thread(() -> {
34
            for (int i = 0; i < 10; i++) {
35
                try {
36
                    data.printC();
37
                } catch (InterruptedException e) {
38
                    e.printStackTrace();
39
                }
40
            }
41
        }, "C").start();
42
    }
43
}
44
// 判断等待，业务，通知
45
class Data3 {
46
    Integer num = 1;
47

48
    Lock lock = new ReentrantLock();
49
    // 创建多个condition
50
    Condition condition1 = lock.newCondition();
51
    Condition condition2 = lock.newCondition();
52
    Condition condition3 = lock.newCondition();
53

54
    public  void printA() throws InterruptedException {
55
        lock.lock();
56
        try {
57
            while (num != 1) {
58
                try {
59
                    condition1.await();
60
                } catch (InterruptedException e) {
61
                    e.printStackTrace();
62
                }
63
            }
64
            num = 2;
65
            // 唤醒B
66
            condition2.signal();
67
            System.out.println(Thread.currentThread().getName());
68
        } catch (Exception e) {
69
            e.printStackTrace();
70
        } finally {
71
            lock.unlock();
72
        }
73
    }
74

75
    public void printB() throws InterruptedException{
76
        lock.lock();
77
        try {
78
            while (num != 2) {
79
                try {
80
                    condition2.await();
81
                } catch (InterruptedException e) {
82
                    e.printStackTrace();
83
                }
84
            }
85
            num = 3;
86
            // 唤醒C
87
            condition3.signal();
88
            System.out.println(Thread.currentThread().getName());
89
        } catch (Exception e) {
90
           e.printStackTrace();
91
        } finally {
92
            lock.unlock();
93
        }
94
    }
95

96
    public void printC() throws InterruptedException{
97
        lock.lock();
98
        try {
99
            while (num != 3) {
100
                try {
101
                    condition3.await();
102
                } catch (InterruptedException e) {
103
                    e.printStackTrace();
104
                }
105
            }
106
            num = 1;
107
            // 唤醒A
108
            condition1.signal();
109
            System.out.println(Thread.currentThread().getName());
110
        } catch (Exception e) {
111
           e.printStackTrace();
112
        } finally {
113
            lock.unlock();
114
        }
115
    }
116
}
117

118
/*
119
A==> AAAA
120
B==> BBBB
121
C==> CCCC
122
A==> AAAA
123
B==> BBBB
124
C==> CCCC
125
...
126
*/

1
//java.util.ConcurrentModificationException 并发修改异常！
2
public class ListTest {
3
    public static void main(String[] args) {
4

5
        List<Object> arrayList = new ArrayList<>();
6

7
        for(int i=1;i<=10;i++){
8
            new Thread(()->{
9
                arrayList.add(UUID.randomUUID().toString().substring(0,5));
10
                System.out.println(arrayList);
11
            },String.valueOf(i)).start();
12
        }
13

14
    }
15
}

1
public class ListTest {
2
    public static void main(String[] args) {
3
        /**
4
         * 解决方案
5
         * 1. List<String> list = new Vector<>();
6
         * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
7
         * 3. List<String> list = new CopyOnWriteArrayList<>();
8
         */
9
        List<String> list = new CopyOnWriteArrayList<>();
10

11

12
        for (int i = 1; i <=10; i++) {
13
            new Thread(() -> {
14
                list.add(UUID.randomUUID().toString().substring(0,5));
15
                System.out.println(list);
16
            },String.valueOf(i)).start();
17
        }
18
    }
19
}

1
public class SetTest {
2
    public static void main(String[] args) {
3
        /**
4
         * 1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
5
         * 2. Set<String> set = new CopyOnWriteArraySet<>();
6
         */
7
//        Set<String> set = new HashSet<>();
8
        Set<String> set = new CopyOnWriteArraySet<>();
9

10
        for (int i = 1; i <= 30; i++) {
11
            new Thread(() -> {
12
                set.add(UUID.randomUUID().toString().substring(0,5));
13
                System.out.println(set);
14
            },String.valueOf(i)).start();
15
        }
16
    }
17
}

1
//map 是这样用的吗？  不是，工作中不使用这个
2
//默认等价什么？ new HashMap<>(16,0.75);
3
Map<String, String> map = new HashMap<>();
4
//加载因子、初始化容量

1
public class MapTest {
2
    public static void main(String[] args) {
3
        //map 是这样用的吗？  不是，工作中不使用这个
4
        //默认等价什么？ new HashMap<>(16,0.75);
5
        /**
6
         * 解决方案
7
         * 1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
8
         *  Map<String, String> map = new ConcurrentHashMap<>();
9
         */
10
        Map<String, String> map = new ConcurrentHashMap<>();
11
        //加载因子、初始化容量
12
        for (int i = 1; i < 100; i++) {
13
            new Thread(()->{
14
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
15
                System.out.println(map);
16
            },String.valueOf(i)).start();
17
        }
18
    }
19
}

1
package com.example.juc.CountDownLatch;
2

3
import java.util.concurrent.CountDownLatch;
4

5
public class CountDownLatchDemo {
6
    public static void main(String[] args) throws InterruptedException {
7
        CountDownLatch countDownLatch = new CountDownLatch(6);
8
        for (int i = 1; i <= 6; i++) {
9
            new Thread(() -> {
10
                System.out.println(Thread.currentThread().getName());
11
                countDownLatch.countDown();
12
            },String.valueOf(i)).start();
13
        }
14
        countDownLatch.await();
15

16
        System.out.println("以上线程执行完毕");
17
    }
18
}

1
package com.example.juc.add;
2

3
import java.util.concurrent.CyclicBarrier;
4

5
public class CyClickBarrierDemo {
6
    public static void main(String[] args) {
7
        // 公共屏障点为7，当7个线程都到达屏障点时，执行召唤神龙
8
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7 , () -> {
9
            System.out.println("召唤神龙");
10
        });
11
        for (int i = 1; i <= 7; i++) {
12
            new Thread(() -> {
13
                System.out.println(Thread.currentThread().getName() + "集齐7颗龙珠");
14
                try {
15
                    cyclicBarrier.await();
16
                } catch (Exception e) {
17
                    e.printStackTrace();
18
                }
19
            },String.valueOf(i)).start();
20
        }
21
        System.out.println("上面线程已经全部执行");
22
    }
23
}