本文主要是介绍java线程 yield,sleep,join，synchronized wait notify notifyAll，ReentrantLock lock condition, 生产者消费者，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
yield,sleep,join
yield,join,sleep,join是Thread中的方法，不需要 在synchronized 代码块中调用，和synchronized 没关系，也不会释放锁。
Thread.sleep(100);
Thread.yield();
Thread t;
t.join();（1）yield()不一定保证让出cpu
yield()只是使当前线程重新回到可执行状态，所有执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以yield()方法只能使同优先级的线程有执行的机会。
（2）sleep 不释放锁
（3）加join 会等join的线程 执行完后父线程才执行。
wait notify notifyAll
wait notify notifyAll 是object对象的方法，必须在必须在 synchronized 代码块中调用。
s.wait：释放锁并阻塞
s.notify，s.notifyAll：是唤醒s.wait的一个线程，notifyAll是唤醒所有s.wait线程。
注意：
（1）被唤醒的线程不一定会立刻获得锁执行，而是进入该对象的锁池中，锁池中的线程会去竞争该对象锁。
（2）调用notify 和notifyAll 后，会当前调用的notify 或notifyAll所在的 synchronized 块执行完后，才会释放锁。
（3）调用notify 和notifyAll后 当前线程不会阻塞，而是和其他在该锁池中的线程一样，可以竞争锁。所以调用notify 和notifyAll后 不一定是被唤醒的s.wait 线程 先获得锁执行，也可能当前notify 的线程再次获得锁执行，只不过唤醒s.wait线程 会一次一次的竞争锁，直到获得锁进行执行 。
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。
优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
Reference：线程间协作：wait、notify、notifyAll
综上，所谓唤醒线程，另一种解释可以说是将线程由等待池移动到锁池，notifyAll调用后，会将全部线程由等待池移到锁池，然后参与锁的竞争，竞争成功则继续执行，如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。
有了这些理论基础，后面的notify可能会导致死锁，而notifyAll则不会的例子也就好解释了
生产者代码示例
package java1;import java.util.Date;
import java.util.LinkedList;
import java.util.List;
class EventStorage {private int maxSize;private List<Date> storage;public EventStorage() {maxSize = 10;storage = new LinkedList<Date>();}public synchronized void set() {if(storage.size() == maxSize) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}storage.add(new Date());System.out.println("Set: "+storage.size());notifyAll();}public synchronized void get() {if(storage.size() == 0) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("Get: "+storage.size()+" "+((LinkedList<Date>)storage).poll());notifyAll();}
}
class Producer implements Runnable {private EventStorage storge;public Producer(EventStorage storage) {this.storge = storage;}public void run() {for(int i = 0; i < 100; i++) {storge.set();}}
}
class Consumer implements Runnable {private EventStorage storage;public Consumer(EventStorage storage) {this.storage = storage;}public void run() {for (int i = 0; i < 100; i++) {storage.get();}}
}
//生产者消费者的两个wait()，会一个先执行到进行阻塞，后一个也执行到进行阻塞，但后一个执行wait阻塞的前一次for 循环 执行了 notifyAll，所以先执行wait() 的会被唤醒，进入竞争锁的池 进行竞争锁。 因此永远不会出现 get set 两个wait都处在没被唤醒的状态。
public class ProducerAndConsumer {public static void main(String[] args){EventStorage eventStorage=new EventStorage();Thread t1=new Thread(new Producer(eventStorage));Thread t2=new Thread(new Consumer(eventStorage));t1.start();t2.start();}
}ReentrantLock lock condition
condition的await，signal ，signalAll 类似于synchronized 中的 wait,notify，notifyAll。但 condition可以有多个，即new 多个不同的Condition 来实现 阻塞于唤醒。
同样的
（1）signal ，signalAll 必须在lock代码块中执行
（2）signal ，signalAll 执行完后不会立即释放锁，而是等lock代码块中的代码执行完后才释放锁。
生产者消费者
package java1;import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;public class Test5 {static volatile int i = 0;static final ReentrantLock LOCK = new ReentrantLock();static final Condition condition = LOCK.newCondition();public static void add() throws InterruptedException {LOCK.lock();try {if (i == 0) {System.out.print("add\t");System.out.println(++i);System.out.println("add1");condition.signal();System.out.println("add2");condition.await();}}finally {LOCK.unlock();}}public static void sub() throws InterruptedException {LOCK.lock();try {if (i == 1) {System.out.print("sub\t");System.out.println(--i);System.out.println("sub1");condition.signal();System.out.println("sub2");condition.await();}}finally {LOCK.unlock();}}public static void main(String[] args) throws InterruptedException {new Thread(() -> {while (true) {try {//Thread.sleep(1000);add();} catch (InterruptedException e) {e.printStackTrace();}}}).start();new Thread(() -> {while (true) {try {//Thread.sleep(1000);sub();} catch (InterruptedException e) {e.printStackTrace();}}}).start();}
}
这篇关于java线程 yield,sleep,join，synchronized wait notify notifyAll，ReentrantLock lock condition, 生产者消费者的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
