1、固定运行顺序
比如，必须先 2 后 1 打印
1.1、wait notify 版
public class Test1 {// 先打印2，后打印1static final Object lock = new Object();static boolean t2runned = false; //表示t2是否运行过public static void main(String[] args) {Thread t1 = new Thread(()->{synchronized (lock){while(!t2runned){try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}}System.out.println(Thread.currentThread().getName() + ": " + "1");}, "t1");Thread t2 = new Thread(()->{synchronized (lock) {System.out.println(Thread.currentThread().getName() + ": " + "2");t2runned = true;lock.notifyAll();}}, "t2");t1.start();t2.start();}
}
1.2、Park Unpark 版
可以看到，实现上很麻烦：
● 首先，需要保证先 wait 再 notify，否则 wait 线程永远得不到唤醒。因此使用了『运行标记』来判断该不该 wait 。
● 第二，如果有些干扰线程错误地 notify 了 wait 线程，条件不满足时还要重新等待，使用了 while 循环来解决 此问题。
● 最后，唤醒对象上的 wait 线程需要使用 notifyAll，因为『同步对象』上的等待线程可能不止一个
可以使用 LockSupport 类的 park 和 unpark 来简化上面的题目：
import java.util.concurrent.locks.LockSupport;public class Test2 {public static void main(String[] args) {Thread t1 = new Thread(()->{LockSupport.park();System.out.println(Thread.currentThread().getName() + ": " + "1");},"t1");t1.start();Thread t2 = new Thread(()->{System.out.println(Thread.currentThread().getName() + ": " + "2");LockSupport.unpark(t1);},"t2");t2.start();}
}
2、交替打印abc
线程 1 输出 a 5 次，线程 2 输出 b 5 次，线程 3 输出 c 5 次。现在要求输出 abcabcabcabcabc 怎么实现
2.1 wait notify 版
public class Test3 {public static void main(String[] args) {WaitNotify wt = new WaitNotify(1, 5);new Thread(()->{wt.print("a", 1, 2);}).start();new Thread(()->{wt.print("b", 2, 3);}).start();new Thread(()->{wt.print("c", 3, 1);}).start();}
}/*
输出内容 等待标记 下一个标记a 1 2b 2 3c 3 1
*/
class WaitNotify{// 打印 a 1 2public void print(String str, int waitFlag, int nextFlag){for (int i = 0; i < loopNumber; i++) {synchronized (this){while(waitFlag != flag)try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.print(str);flag = nextFlag;this.notifyAll();}}}private int flag; //等待标记 1private int loopNumber; //循环次数public WaitNotify(int flag, int loopNumber) {this.flag = flag;this.loopNumber = loopNumber;}
}
3、交替打印奇偶数
两个线程交替打印0~100的奇偶数
● 偶线程：0
● 奇线程：1
● 偶线程：2
3.1、synchronized实现
缺点：效率低，会出现浪费的竞争。比如说，一直是偶数线程拿到锁，进行判断后不满足条件，就不会去执行打印语句，然后跳出，这样的话很多次竞争拿到锁是没有意义的。
import com.sun.javaws.IconUtil;/*
两个线程交替打印0~100的奇偶数，用synchronized关键字实现*/
public class WaitNotifyPrintOddEvenSyn {private static int count;private static final Object lock = new Object();//新建两个线程//1个只处理偶数，第二个只处理奇数（用位运算)//用synchronized来通信public static void main(String[] args) {new Thread( ()->{while(count < 100){synchronized (lock){if((count & 1) == 0){System.out.println(Thread.currentThread().getName() + ":" + count++);}}}}, "偶数").start();new Thread(()->{while(count < 100){synchronized (lock){if((count & 1) == 1){System.out.println(Thread.currentThread().getName() + ":" + count++);}}}}, "奇数").start();}
}
3.2、wait/notify
优点：效率高，一个线程拿到锁就去打印，打印完，唤醒其他线程，自己就休眠，每次的竞争都是有意义的。
import javax.sound.sampled.FloatControl;
/*两个线程交替打印0~100的奇偶数，用wait/notify实现*/
public class WaitNotifyPrintOddEvenWait {private static int count = 0;private static Object lock = new Object();public static void main(String[] args) throws InterruptedException {new Thread(new TurningRunner(), "偶数").start();Thread.sleep(100);new Thread(new TurningRunner(), "奇数").start();}// 1.拿到锁，我们就打印// 2.打印完，唤醒其他线程，自己就休眠static class TurningRunner implements Runnable{@Overridepublic void run() {while(count <= 100){synchronized (lock){// 拿到锁就打印System.out.println(Thread.currentThread().getName() + ":" + count++);lock.notify();if(count <= 100){// 如果任务还没结束，就让出当期的锁，并休眠try {lock.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}
}
