1
Thread.State
2

3

4

5
public enum State {
6
    /**
7
     * Thread state for a thread which has not yet started.
8
     */
9
    NEW,(新建)
10

11
    /**
12
     * Thread state for a runnable thread.  A thread in the runnable
13
     * state is executing in the Java virtual machine but it may
14
     * be waiting for other resources from the operating system
15
     * such as processor.
16
     */
17
    RUNNABLE,（准备就绪）
18

19
    /**
20
     * Thread state for a thread blocked waiting for a monitor lock.
21
     * A thread in the blocked state is waiting for a monitor lock
22
     * to enter a synchronized block/method or
23
     * reenter a synchronized block/method after calling
24
     * {@link Object#wait() Object.wait}.
25
     */
26
    BLOCKED,（阻塞）
27

28
    /**
29
     * Thread state for a waiting thread.
30
     * A thread is in the waiting state due to calling one of the
31
     * following methods:
32
     * <ul>
33
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
34
     *   <li>{@link #join() Thread.join} with no timeout</li>
35
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
36
     * </ul>
37
     *
38
     * <p>A thread in the waiting state is waiting for another thread to
39
     * perform a particular action.
40
     *
41
     * For example, a thread that has called <tt>Object.wait()</tt>
42
     * on an object is waiting for another thread to call
43
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
44
     * that object. A thread that has called <tt>Thread.join()</tt>
45
     * is waiting for a specified thread to terminate.
46
     */
47
    WAITING,（不见不散）
48

49
    /**
50
     * Thread state for a waiting thread with a specified waiting time.
51
     * A thread is in the timed waiting state due to calling one of
52
     * the following methods with a specified positive waiting time:
53
     * <ul>
54
     *   <li>{@link #sleep Thread.sleep}</li>
55
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
56
     *   <li>{@link #join(long) Thread.join} with timeout</li>
57
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
58
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
59
     * </ul>
60
     */
61
    TIMED_WAITING,（过时不候）
62

63
    /**
64
     * Thread state for a terminated thread.
65
     * The thread has completed execution.
66
     */
67
    TERMINATED;(终结)
68
}

1
//资源类
2
@Slf4j
3
class Ticket{
4
    private int number = 30;
5

6
    public synchronized void saleTicket(){
7
        if(number > 0){
8
            log.info(Thread.currentThread().getName()+"卖出第：{}",number--,"还剩下：{}",number);
9
        }
10
    }
11
}
12

13
/**
14
 * 题目： 三个售票员  卖出  30张票
15
 *
16
 *多线程编程的企业套路+模板
17
 * 1、在高内聚低耦合的前提下：  线程  操作(对外暴露的调用方法)  资源类
18
 */
19
public class SaleTicket {
20

21
    public static void main(String[] args) {
22
        Ticket ticket = new Ticket();
23

24
        new Thread(new Runnable() {
25
           @Override
26
           public void run() {
27
               for (int i = 0; i < 40; i++) {
28
                   ticket.saleTicket();
29
               }
30
           }
31
       },"A").start();
32

33
        new Thread(new Runnable() {
34
           @Override
35
           public void run() {
36
               for (int i = 0; i < 40; i++) {
37
                   ticket.saleTicket();
38
               }
39
           }
40
       },"B").start();
41

42
        new Thread(new Runnable() {
43
           @Override
44
           public void run() {
45
               for (int i = 0; i < 40; i++) {
46
                   ticket.saleTicket();
47
               }
48
           }
49
       },"C").start();
50

51
    }
52
}

1
class X {
2
   private final ReentrantLock lock = new ReentrantLock();
3
   // ...
4

5
   public void m() {
6
     lock.lock();  // block until condition holds
7
     try {
8
       // ... method body
9
     } finally {
10
       lock.unlock()
11
     }
12
   }
13
 }
14

15

16
synchronized与Lock的区别
17

18
两者区别：
19
1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
20
2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
21
3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，
22
    Lock需在finally中手工释放锁（unlock()方法释放锁），s否则容易造成线程死锁；
23
4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。
24
    如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
25
5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可中断、可公平（两者皆可）
26
6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

1
//资源类
2
@Slf4j
3
class Ticket{
4
    private int number = 30;
5

6
    private final Lock lock = new ReentrantLock();
7

8
    public void saleTicket(){
9
        lock.lock();
10
        try {
11
            if(number > 0){
12
                log.info(Thread.currentThread().getName()+"卖出第：{}",number--,"还剩下：{}",number);
13
            }
14
        }finally {
15
            lock.unlock();
16
        }
17

18
    }
19
}
20

21
/**
22
 * 题目： 三个售票员  卖出  30张票
23
 *
24
 *多线程编程的企业套路+模板
25
 * 1、在高内聚低耦合的前提下：  线程  操作(对外暴露的调用方法)  资源类
26
 */
27
public class SaleTicket {
28

29
    public static void main(String[] args) {
30
        Ticket ticket = new Ticket();
31

32
        new Thread(new Runnable() {
33
           @Override
34
           public void run() {
35
               for (int i = 0; i < 40; i++) {
36
                   ticket.saleTicket();
37
               }
38
           }
39
       },"A").start();
40

41
        new Thread(new Runnable() {
42
           @Override
43
           public void run() {
44
               for (int i = 0; i < 40; i++) {
45
                   ticket.saleTicket();
46
               }
47
           }
48
       },"B").start();
49

50
        new Thread(new Runnable() {
51
           @Override
52
           public void run() {
53
               for (int i = 0; i < 40; i++) {
54
                   ticket.saleTicket();
55
               }
56
           }
57
       },"C").start();
58

59
    }
60
}

1
public class SaleTicket extends Thread
2

3
java是单继承，资源宝贵，要用接口方式

1
Thread t1 = new Thread();
2
   t1.start();

1
class MyThread implements Runnable//新建类实现runnable接口
2

3
new Thread(new MyThread,...)
4

5
这种方法会新增类，有更好的方法

1
new Thread(new Runnable() {
2
    @Override
3
    public void run() {
4

5
    }
6
   }, "your thread name").start();
7

8
 这种方法不需要创建新的类，可以new接口

1
new Thread(() -> {
2

3
 }, "your thread name").start();
4

5
  这种方法代码更简洁精炼

1
//资源类
2
@Slf4j
3
class Ticket{
4
    private int number = 30;
5

6
    private final Lock lock = new ReentrantLock();
7

8
    public void saleTicket(){
9
        lock.lock();
10
        try {
11
            if(number > 0){
12
                log.info(Thread.currentThread().getName()+"卖出第：{}",number--,"还剩下：{}",number);
13
            }
14
        }finally {
15
            lock.unlock();
16
        }
17

18
    }
19
}
20

21
/**
22
 * 题目： 三个售票员  卖出  30张票
23
 *
24
 *多线程编程的企业套路+模板
25
 * 1、在高内聚低耦合的前提下：  线程  操作(对外暴露的调用方法)  资源类
26
 */
27
public class SaleTicket {
28

29
    public static void main(String[] args) {
30
        Ticket ticket = new Ticket();
31

32
        new Thread(() ->{
33
            for (int i = 0; i <40; i++) {
34
                ticket.saleTicket();
35
            }
36
        },"A").start();
37
        new Thread(() ->{
38
            for (int i = 0; i <40; i++) {
39
                ticket.saleTicket();
40
            }
41
        },"B").start();
42

43
    }
44
}

1
package com.atguigu.thread;
2

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

7

8

9
class ShareDataOne//资源类
10
{
11
  private int number = 0;//初始值为零的一个变量
12

13
  //为0时加1，不为0时进入等待
14
  public synchronized void increment() throws InterruptedException
15
  {
16
     //1判断
17
     if(number !=0 ) {
18
       this.wait();
19
     }
20
     //2干活
21
     ++number;
22
     System.out.println(Thread.currentThread().getName()+"\t"+number);
23
     //3通知
24
     this.notifyAll();
25
  }
26

27
  //为0时进入等待，不为0时减1
28
  public synchronized void decrement() throws InterruptedException
29
  {
30
     // 1判断
31
     if (number == 0) {
32
       this.wait();
33
     }
34
     // 2干活
35
     --number;
36
     System.out.println(Thread.currentThread().getName() + "\t" + number);
37
     // 3通知
38
     this.notifyAll();
39
  }
40
}
41

42
/**
43
 *
44
 * @Description:
45
 *现在两个线程，
46
 * 可以操作初始值为零的一个变量，
47
 * 实现一个线程对该变量加1，一个线程对该变量减1，
48
 * 交替，来10轮。
49
 * @author xialei
50
 *
51
 *  * 笔记：Java里面如何进行工程级别的多线程编写
52
 * 1 多线程变成模板（套路）-----上
53
 *     1.1  线程    操作    资源类
54
 *     1.2  高内聚  低耦合
55
 * 2 多线程变成模板（套路）-----下
56
 *     2.1  判断
57
 *     2.2  干活
58
 *     2.3  通知
59

60
 */
61
public class NotifyWaitDemoOne
62
{
63
  public static void main(String[] args)
64
  {
65
     ShareDataOne sd = new ShareDataOne();
66
     new Thread(() -> {
67
       for (int i = 1; i < 10; i++) {
68
          try {
69
            sd.increment();
70
          } catch (InterruptedException e) {
71
            // TODO Auto-generated catch block
72
            e.printStackTrace();
73
          }
74
       }
75
     }, "A").start();
76
     new Thread(() -> {
77
       for (int i = 1; i < 10; i++) {
78
          try {
79
            sd.decrement();
80
          } catch (InterruptedException e) {
81
            // TODO Auto-generated catch block
82
            e.printStackTrace();
83
          }
84
       }
85
     }, "B").start();
86
  }
87
}
88
/*
89
 * *
90
 * 2 多线程变成模板（套路）-----下
91
 *     2.1  判断
92
 *     2.2  干活
93
 *     2.3  通知
94
 * 3 防止虚假唤醒用while
95
 * 虚假唤醒（Spurious Wakeup）是指在多线程编程中，有时候线程可能会在没有显式调用 notify 或 notifyAll 的情况下被唤醒，
96
   即使条件并未满足。
97
   为了防止虚假唤醒，应该使用 while 循环来进行条件的检查，而不是使用 if 语句。
98
 *
99
 * */
100
class ShareDataOne {
101
    private int number = 0;
102

103
    private final Lock lock = new ReentrantLock();
104
    private final Condition condition = lock.newCondition();
105

106
    public void increment() throws InterruptedException {
107
        lock.lock();
108
        try {
109
            while (number != 0) { // 使用while循环判断条件
110
                condition.await();
111
            }
112
            ++number;
113
            System.out.println(Thread.currentThread().getName() + "\t" + number);
114
            condition.signalAll();
115
        } finally {
116
            lock.unlock();
117
        }
118
    }
119

120
    public void decrement() throws InterruptedException {
121
        lock.lock();
122
        try {
123
            while (number == 0) { // 使用while循环判断条件
124
                condition.await();
125
            }
126
            --number;
127
            System.out.println(Thread.currentThread().getName() + "\t" + number);
128
            condition.signalAll();
129
        } finally {
130
            lock.unlock();
131
        }
132
    }
133
}

1
class BoundedBuffer {
2
   final Lock lock = new ReentrantLock();
3
   final Condition notFull  = lock.newCondition();
4
   final Condition notEmpty = lock.newCondition();
5

6
   final Object[] items = new Object[100];
7
   int putptr, takeptr, count;
8

9
   public void put(Object x) throws InterruptedException {
10
     lock.lock();
11
     try {
12
       while (count == items.length)
13
         notFull.await();
14
       items[putptr] = x;
15
       if (++putptr == items.length) putptr = 0;
16
       ++count;
17
       notEmpty.signal();
18
     } finally {
19
       lock.unlock();
20
     }
21
   }