线程方法概览
1. wait,notify,notifyAll方法详解
.1 wait-notify用法
● 我们创建两个线程类，用一个object对象加锁，然后一个线程调用object.wati()，另一个调用object.notify()，且wait先执行。
● 先看一段代码和结果
/**
* wait和notify的基本用法
* 1. 代码的执行顺序
* 2. wait释放锁
*/
public class Wait {
private final static Object object = new Object();
static class ThreadOne extends Thread {
@Override
public void run() {
synchronized (object) {
try {
System.out.println(Thread.currentThread().getName() + " in run before wait");
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " in run after wait");
}
}
}
static class ThreadTwo extends Thread {
@Override
public void run() {
synchronized (object) {
System.out.println(Thread.currentThread().getName() + " in run before notify");
object.notify();
System.out.println(Thread.currentThread().getName() + " in run after notify");
}
}
}
public static void main(String[] args) throws InterruptedException {
ThreadOne threadOne = new ThreadOne();
ThreadTwo threadTwo = new ThreadTwo();
threadOne.start();
Thread.sleep(100);
threadTwo.start();
}
}
运行结果
Thread-0 in run before wait
Thread-1 in run before notify
Thread-1 in run after notify
Thread-0 in run after wait
Process finished with exit code 0
● 执行顺序如上结果，执行解释如下
● Thread-0先进入执行，然后wait()进入等待唤醒的WAITING状态，并释放锁。
● Thread-1后进入执行，发现加锁了，然后等待Thread-0释放锁过后调用notify()通知Thread-0不用等了，不过此时由于Thread-1持有了object的锁，所以Thread-1先执行完毕后释放锁，然后Thread-0再拿到锁，把wait()后面的代码执行完毕。
1.2 wait-notifyAll 用法
● 创建三个线程，两个线程wait，然后用第三个线程调用notifyAll唤醒
● 代码和即如果如下
/**
* 三个线程 2个被wait阻塞，另一个来唤醒他们
*
*/
public class WaitNotifyAll implements Runnable {
private static final Object objectOne = new Object();
@Override
public void run() {
synchronized (objectOne) {
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + " in run before wait, state is " + currentThread.getState());
try {
objectOne.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(currentThread.getName() + " in run after wait, state is " + currentThread.getState());
}
}
public static void main(String[] args) throws InterruptedException {
WaitNotifyAll waitNotifyAll = new WaitNotifyAll();
Thread threadOne = new Thread(waitNotifyAll,"thread-one");
Thread threadTwo = new Thread(waitNotifyAll,"thread-two");
Thread threadThree = new Thread(() -> {
synchronized (objectOne) {
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + " in run before notifyAll, state is " + currentThread.getState());
objectOne.notifyAll();
System.out.println(currentThread.getName() + " in run after notifyAll, state is " + currentThread.getState());
}
}, "thread-three");
threadOne.start();
threadTwo.start();
Thread.sleep(200);
threadThree.start();
}
}
运行结果
thread-one in run before wait, state is RUNNABLE
thread-two in run before wait, state is RUNNABLE
thread-three in run before notifyAll, state is RUNNABLE
thread-three in run after notifyAll, state is RUNNABLE
thread-two in run after wait, state is RUNNABLE
thread-one in run after wait, state is RUNNABLE
Process finished with exit code 0
● 线程1和2分别先后进入到WAITING状态后释放锁，
● 线程3进入run方法后调用notifyAll唤醒，执行完毕run方法 释放锁，线程1和2抢占锁然后执行wait方法后面的代码。
1.3 wait释放锁
● 我们在使用wait的时候，它只会释放它的那把锁，代码入下：
```java
/**
* 证明wait 只释放当前的那把锁
*
* @author yiren
*/
public class WaitNotifyReleaseOwnMonitor {
private static final Object objectOne = new Object();
private static final Object objectTwo = new Object();
public static void main(String[] args) throws InterruptedException {
Thread threadOne = new Thread(() -> {
synchronized (objectOne) {
System.out.println(Thread.currentThread().getName() + " got objectOne lock ");
synchronized (objectTwo) {
System.out.println(Thread.currentThread().getName() + " got objectTwo lock ");
try {
System.out.println(Thread.currentThread().getName() + " release objectOne lock ");
objectOne.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
Thread threadTwo = new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (objectOne) {
System.out.println(Thread.currentThread().getName() + " got lock objectOne");
synchronized (objectTwo) {
System.out.println(Thread.currentThread().getName() + " got lock objectTwo");
}
}
});
threadOne.start();
threadTwo.start();
}
}
运行结果
Thread-0 got objectOne lock
Thread-0 got objectTwo lock
Thread-0 release objectOne lock
Thread-1 got lock objectOne
● 注意上面的运行并没有介绍。因为两个线程都还没有执行完毕。
1.4 wait、notify、notifyAll特点和性质
● 使用时必须先拥有monitor，也就是获取到这个对象的锁
● notify只唤醒一个，取决于JVM。notifyAll则是唤醒全部。
● 都是数据Object的对象的方法，且都是final修饰的native方法。
● 类似功能的有一个Condition对象
● 如果线程同时持有多把锁一定要注意释放顺序，不然容易产生死锁。
1.5 生产者消费者模式实现
/**
* 用wait notify实现生产者消费者模式
*/
public class ProducerConsumer {
public static void main(String[] args) {
EventStorage storage = new EventStorage();
Thread producerThread = new Thread(new Producer(storage));
Thread consumerThread = new Thread(new Consumer(storage));
producerThread.start();
consumerThread.start();
}
private static class Producer implements Runnable{
EventStorage storage;
public Producer(EventStorage storage) {
this.storage = storage;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
storage.put();
}
}
}
private static class Consumer implements Runnable{
EventStorage storage;
public Consumer(EventStorage storage) {
this.storage = storage;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
storage.take();
}
}
}
private static class EventStorage {
private int maxSize;
private LinkedList<LocalDateTime> storage;
public EventStorage() {
maxSize = 10;
storage = new LinkedList<>();
}
public synchronized void put() {
while (storage.size() == maxSize) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
storage.add(LocalDateTime.now());
System.out.println("storage has " + storage.size() + " product(s).");
notify();
}
public synchronized void take() {
while (storage.size() == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("get date " + storage.poll() + ", storage has " + storage.size() + " product(s).");
notify();
}
}
}
运行结果
storage has 1 product(s).
storage has 2 product(s).
storage has 3 product(s).
storage has 4 product(s).
storage has 5 product(s).
storage has 6 product(s).
storage has 7 product(s).
storage has 8 product(s).
storage has 9 product(s).
storage has 10 product(s).
get date 2020-02-11T15:46:43.554, storage has 9 product(s).
get date 2020-02-11T15:46:43.554, storage has 8 product(s).
get date 2020-02-11T15:46:43.554, storage has 7 product(s).
get date 2020-02-11T15:46:43.554, storage has 6 product(s).
get date 2020-02-11T15:46:43.554, storage has 5 product(s).
get date 2020-02-11T15:46:43.554, storage has 4 product(s).
get date 2020-02-11T15:46:43.554, storage has 3 product(s).
get date 2020-02-11T15:46:43.554, storage has 2 product(s).
get date 2020-02-11T15:46:43.554, storage has 1 product(s).
get date 2020-02-11T15:46:43.555, storage has 0 product(s).
storage has 1 product(s).
storage has 2 product(s).
storage has 3 product(s).
storage has 4 product(s).
get date 2020-02-11T15:46:43.555, storage has 3 product(s).
get date 2020-02-11T15:46:43.555, storage has 2 product(s).
get date 2020-02-11T15:46:43.555, storage has 1 product(s).
get date 2020-02-11T15:46:43.555, storage has 0 product(s).
1.6 常见问题
● 两个线程交替打印0-100的奇偶数
- 用synchronized来实现
public class OddEvenBySync {
/*
两个线程
1. 一个处理偶数(Even)，另一个处理奇数(Odd) 用位运算来实现判断
2. 用synchronized 来实现
*/
private static volatile int count = 0;
private static final Object lock = new Object();
public static void main(String[] args) {
Thread threadEven = new Thread(() -> {
while (count < 100) {
synchronized (lock) {
// if (count % 2 == 0) {
if (0 == (count & 1)) {
System.out.println(Thread.currentThread().getName() + ": " + count++);
}
}
}
}, "thread-even");
Thread threadOdd = new Thread(() -> {
while (count < 100) {
synchronized (lock) {
// if (count % 2 == 0) {
if (1 == (count & 1)) {
System.out.println(Thread.currentThread().getName() + ": " + count++);
}
}
}
}, "thread-odd");
threadEven.start();
threadOdd.start();
}
}
- 用wait-notify实现
public class OddEvenByWaitNotify {
private static final Object lock = new Object();
private static int count = 0;
private static final int MAX_COUNT = 100;
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
while (count <= MAX_COUNT ) {
synchronized (lock) {
try {
System.out.println(Thread.currentThread().getName() + ": " + count++);
lock.notify();
// 如果任务还没结束 就让出锁 自己休眠
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
● 手写生产者消费者设计模式 （前面有代码）
● 为什么wait()需要在同步代码块中实现，而sleep不需要
a. wait设计是针对多个线程的，如果多个线程运行的时候，在执行wait前就切换到了另外一个线程，恰好把notify执行掉了，那么就会形成死锁。
b. 而sleep则是针对单个线程本身，不涉及到其他线程。
● 为什么线程通信的方法wait(),notify()和notifyAll()被定义在Object类里面？而Sleep定义在Thread类里面？
a. wait(),notify(),notifyAll()属于锁级别的操作，而锁一般是针对某个对象的，所以就定义在了Object中。每一个对象，在对象头中，都是有几位来表示当前锁的状态的，所以这个锁是绑定到某个对象上面，而并不是线程中。
b. 如果把这些方法放在了Thread中，那么如果一个线程中持有了多把锁，就没有办法灵活的实现这样的多锁逻辑，也会增加编程难度。
● wait()方法属于Object对象，那如果调用Thread.wait方法会怎样？
● 对于Thread类特别特殊，因为在JVM中，线程在退出的现实中，它会自己去执行notify，这样会使我们设计的程序受到干扰。
● 如何选择用notify和notifyAll
○ 主要考虑是我们需要唤醒的是单个线程还是多个线程
● notifyAll之后所有的线程都会再次抢夺锁，如果某线程抢夺锁失败怎么办？
○ notifyAll线程执行完同步块中代码后，其他线程会同时竞争这把锁，只有一个线程会竞争成功，其他线程会进入到WAITING状态，等待竞争成功的这个线程执行结束再次竞争锁
● 能不能用suspend()和resume()来阻塞线程？为什么？
○ Java官方是不推荐使用suspend来阻塞线程的，并且两个方法以及注明了过时，推荐使用wait-notify来实现
2. Sleep方法详解
● 让线程在预期的时间执行，其他事件不要占用CPU资源
● wait()会释放锁，但是sleep()方法不释放锁，包括synchronized和lock
2.1 sleep不释放锁
1. synchronized
public class SleepDontReleaseMonitor {
public static void main(String[] args) {
final Object object = new Object();
Runnable runnable = new Runnable() {
@Override
public void run() {
synchronized (object) {
System.out.println(Thread.currentThread().getName() + " into synchronized !");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " out to synchronized !");
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
2. Lock
public class SleepDontReleaseLock {
private static final Lock LOCK = new ReentrantLock();
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
LOCK.lock();
try {
System.out.println(Thread.currentThread().getName() + " into LOCK !");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + " out to LOCK !");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
LOCK.unlock();
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
2.2 响应中断
● 在调用时，会抛出InterruptedException，并且清除中断状态
/**
* sleep响应中断案例
* Thread.sleep()
* TimeUnit.SECONDS.sleep()
*
* @author yiren
*/
public class SleepInterrupted {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ": " + LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + ": was interrupted!");
}
}
});
thread.start();
Thread.sleep(3500);
thread.interrupt();
}
}
● sleep(time)可以通过TimeUnit.时间单位.sleep(time)调用;此方法优于Thread.sleep(time)我们可以看下它的源码，它做了一个大于零的判断，以免传入负数，而Thread.sleep(time)中如果传入负数则会报IllegalArgumentException错误。
public void sleep(long timeout) throws InterruptedException {
if (timeout > 0) {
long ms = toMillis(timeout);
int ns = excessNanos(timeout, ms);
Thread.sleep(ms, ns);
}
}
2.3 一句话总结
● sleep(time)方法可以让线程进入到WAITING状态，并停止占用CPU资源，但是不释放锁，直到规定事件后再执行，休眠期间如果被中断，会抛出异常并清除中断状态。
2.4 常见问题
● wait/notify、sleep异同
○ 方法属于哪个对象？线程状态怎么切换。
○ 相同：都进入阻塞，都响应中断
○ 不同：wait/notify需要同步块，sleep不需要；wait释放锁，sleep不释放；wait可不指定时间，sleep必须指定；所属类不同
3. join方法详解
3.1 作用及用法
● 作用：新线程加入，所以要等待它执行完再出发
● 用法：main等待thread1、thread2等线程执行完毕
- 普通用法
public class JoinSimple {
public static void main(String[] args) throws InterruptedException {
Runnable runnable = () -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " was finished!");
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
System.out.println("start to wait child threads.");
thread1.join();
thread2.join();
System.out.println("all threads run completed!");
}
}
start to wait child threads.
Thread-0 was finished!
Thread-1 was finished!
all threads run completed!
Process finished with exit code 0
○ 如果两个线程不join的话就会先打印最后一句话。
- 中断
○ thread.join()响应的中断是执行join方法的这个线程的中断 而不是thread，就如下方代码，中断的是主线程。
/**
* 响应中断
*/
public class JoinInterrupt {
public static void main(String[] args) {
final Thread mainThread = Thread.currentThread();
Runnable runnable = () -> {
try {
mainThread.interrupt();
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " was finished!");
};
Thread thread1 = new Thread(runnable);
thread1.start();
System.out.println("start to wait child thread.");
try {
thread1.join();
} catch (InterruptedException e) {
// 实际是主线程中断
System.out.println(Thread.currentThread().getName() + " was interrupted!");
e.printStackTrace();
}
}
}
start to wait child thread.
main was interrupted!
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Thread.join(Thread.java:1252)
at java.lang.Thread.join(Thread.java:1326)
at com.imyiren.concurrency.thread.method.JoinInterrupt.main(JoinInterrupt.java:25)
Thread-0 was finished!
Process finished with exit code 0
- join期间线程状态
/**
* join发生后 主线程的状态
*/
public class JoinState {
public static void main(String[] args) {
Thread mainThread = Thread.currentThread();
Thread thread = new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("main thread state: " + mainThread.getState());
System.out.println(Thread.currentThread().getName() + " finished");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread.start();
try {
System.out.println("waiting child thread");
thread.join();
System.out.println("completed child thread");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
waiting child thread
main thread state: WAITING
Thread-0 finished
completed child thread
Process finished with exit code 0
3.2 join源码分析
public final void join() throws InterruptedException {
join(0);
}
public final synchronized void join(long millis) throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
join(0)是代表无限期等待- 它的根本方法就是调用的
wait(time) - 但是没有notify？其实是JVM的Thread执行完毕会自动执行一次notifyAll。
- 既然知道它是通过wait-notify实现的，那么我们可以写一下等价的代码：
public class JoinImplements {
public static void main(String[] args) throws InterruptedException {
Runnable runnable = () -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " was finished!");
};
Thread thread1 = new Thread(runnable);
thread1.start();
System.out.println("start to wait child threads.");
// thread1.join(); // 等价于下方代码
synchronized (thread1) {
thread1.wait();
}
System.out.println("all threads run completed!");
}
}
3.3 常见问题
● 在join期间线程会处于那种状态？
○ WAITING
4. yield方法详解
● 释放当前CPU占用，状态依旧是RUNNABLE
● JVM不保证遵循yield，如CPU资源不紧张，极端点没有线程使用，即使调用yield也有可能不释放CPU资源
● 与sleep的区别：是否可以随时再次被调度
5. Thread.currentThread()方法
● 主要是返回当前线程的引用。
public class CurrentThread {
public static void main(String[] args) {
Runnable runnable = () -> System.out.println(Thread.currentThread().getName());
// 主线程直接调用函数
runnable.run();
new Thread(runnable).start();
new Thread(runnable).start();
}
}
6. start run 方法 和 stop suspend resume 方法
● 详见：线程的停止和中断最佳实践
7. 常见问题
● 为什么线程通信的方法wait(),notify()和notifyAl()被定义在Object类里面？而sleep却定义在Thread类中
● 用三种方法实现生产者模式
● join和sleep和wait期间线程的状态分别是什么？为什么？
2548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
