• 欢迎光临~

两个线程交替打印/卖票问题?(5种方法)

开发技术 开发技术 2022-12-28 次浏览

引言

     设置两个窗口(线程),交替卖出100张票,一个线程卖寄数,一个线程卖偶数,要求交替卖出,最后数据 1 ,2,,3,4,5,6......100

 1 /**
 2  * @ClassName AlternatePrintThread
 3  * @Description 设计两个线程,卖出1-100张票,一个线程打印奇数张,另一个线程打印偶数张,要求交替打印。 最后输出123……100
 4  * @Author zhao's'qing
 5  * @Date 2022/11/10  15:21
 6  * @Version 1.0
 7  **/
 8 public class AlternatePrintThread {
 9 
10     static final Object obj = new Object();
11     private static int flag = 0;
12 
13     private static volatile boolean flag2 = false;
14 
15     private static Lock lock = new ReentrantLock();
16     private static Condition condition = lock.newCondition();
17     private static boolean flag3 = false;
18 
19     public static void main(String[] args) {
20         AlternatePrintThread apt = new AlternatePrintThread();
21         apt.test1();
22         //apt.test2();
23         //apt.test3();
24         //apt.test4();
25         // apt.test5();
26 
27     }
28 }

方法一(Synchronized+共享变量)
    解题思路
    新建一个对象,并定义一个共享变量。只要flag不为1,线程t2就会阻塞,释放锁资源,所以t1线程先执行,此时flag为0,跳过while判断,然后修改flag为1,打印奇数张票,并唤醒t2,由于flag被改为1,下次循环,t1就会阻塞。t2被唤醒后,t1已经释放了锁资源,所以t2可以获取锁资源,并且flag为1,跳过while循环,修改flag为0,打印偶数张票,唤醒t1。

    代码实现:

 1 public void test1(){
 2         Thread t1 = new Thread(() -> {
 3             synchronized (obj) {
 4                 for (int i = 1; i <= 10; i += 2) {
 5                     while (flag != 0) {
 6                         try {
 7                             obj.wait();
 8                             Thread.sleep(200);
 9                         } catch (Exception e) {
10                             e.printStackTrace();
11                         }
12                     }
13                     flag = 1;
14                     System.out.println(Thread.currentThread().getName() + " 卖出第 :" + i +" 张票!");
15                     obj.notify();
16 
17                 }
18             }
19         }, "线程A");
20 
21         Thread t2 = new Thread(()->{
22             synchronized (obj) {
23                 for (int i = 2; i <= 10; i += 2) {
24                     while (flag != 1) {
25                         try {
26                             obj.wait();
27                             Thread.sleep(200);
28                         } catch (Exception e) {
29                             e.printStackTrace();
30                         }
31                     }
32                     flag = 0;
33                     System.out.println(Thread.currentThread().getName() + " 卖出第:" + i +" 张票");
34                     obj.notify();
35                 }
36             }
37         },"线程B");

 结果:

两个线程交替打印/卖票问题?(5种方法)

 

方法二(Volatile)
    解题思路
    定义一个volatile修饰的共享变量flag,当flag为false时,t2线程让出系统资源,自己进入就绪状态,让t1先执行,t1获取资源后,首先跳过while判断,打印奇数,修改flag为true,下次循环时,就会让出资源,此时t2从就绪状态进入执行状态,跳过while判断,打印偶数,修改flag为false,下次循环时,就会让出资源。如此不断交替执行,直到打印完所有奇数偶数张票。

    代码实现:

 1  //方法二(Volatile)
 2     public void test2(){
 3         Thread t1 = new Thread(() -> {
 4             for (int i = 1; i <= 100; i += 2) {
 5                 while (flag2) {
 6                     Thread.yield();
 7                 }
 8                 System.out.println(Thread.currentThread().getName() + " 卖出第 :" + i +" 张票!");
 9                 flag2 = true;
10             }
11 
12         }, "线程A");
13 
14         Thread t2 = new Thread(() -> {
15             for (int i = 2; i <= 100; i += 2) {
16                 while (!flag2) {
17                     Thread.yield();
18                 }
19                 System.out.println(Thread.currentThread().getName() + " 卖出第 :" + i +" 张票!");
20                 flag2 = false;
21             }
22         }, "线程B");
23         t1.start();
24         t2.start();
25     }

 结果:

两个线程交替打印/卖票问题?(5种方法)

   

方法三(Semaphore)
    解题思路
    定义两个信号量,一个许可为1,一个许可为0。首先许可为0的会阻塞,所以t1线程先执行,通过s1.acquire()消耗许可,打印奇数,此时s1许可为0,t1阻塞,同时s2.release()获得一个许可,t2线程通过s2.acquire()消耗许可,打印偶数,此时s2许可又变为0,t2阻塞,同时s1.release()获得一个许可。如此反复执行,直到打印完所有的数。

    代码实现:

 1     //方法三(Semaphore)
 2     public void test3(){
 3         Semaphore s1 = new Semaphore(1);
 4         Semaphore s2 = new Semaphore(0);
 5         Thread t1 = new Thread(() -> {
 6             for (int i = 1; i <= 100; i += 2) {
 7                 try {
 8                     s1.acquire(); //获取令牌
 9                     System.out.println(Thread.currentThread().getName() + " 卖出第 :" + i +" 张票!");
10                     s2.release(); //释放令牌
11                 } catch (Exception e) {
12                     e.printStackTrace();
13                 }
14 
15             }
16         }, "线程A");
17         Thread t2 = new Thread(() -> {
18             for (int i = 2; i <= 100; i += 2) {
19                 try {
20                     s2.acquire();
21                     System.out.println(Thread.currentThread().getName() + " 卖出第 :" + i +" 张票!");
22                     s1.release();
23                 } catch (Exception e) {
24                     e.printStackTrace();
25                 }
26             }
27         }, "线程B");
28         t1.start();
29         t2.start();
30     }

 结果:

两个线程交替打印/卖票问题?(5种方法)

 

方法四(ReentrantLock + Condition)
    解题思路
    首先定义一个lock和一个condition。当flag为false时,t2会阻塞,此时t1先执行,打印奇数张票,通过condition唤醒t2,修改flag为true,下次循环自己就会进入阻塞状态。t2被唤醒后,由于flag已经变为true,跳过while判断,打印偶数张票,唤醒t1,修改flag,自己阻塞,如此反复。

    代码实现:

 1 //方法四(ReentrantLock)
 2     public void test4(){
 3         Thread t1 = new Thread(() -> {
 4             for (int i = 1; i <= 100; i += 2) {
 5                 lock.lock();
 6                 while (flag3) {
 7                     try {
 8                         condition.await();
 9                         Thread.sleep(200);
10                     } catch (Exception e) {
11                         e.printStackTrace();
12                     }
13                 }
14                 System.out.println(Thread.currentThread().getName() + " 卖出第:" + i +"张票");
15                 condition.signal();
16                 flag3 = true;
17                 lock.unlock();
18             }
19         }, "窗口1");
20 
21         Thread t2 = new Thread(() -> {
22             for (int i = 2; i <= 100; i += 2) {
23                 lock.lock();
24                 while (!flag3) {
25                     try {
26                         condition.await();
27                         Thread.sleep(200);
28                     } catch (Exception e) {
29                        e.printStackTrace();
30                     }
31                 }
32                 System.out.println(Thread.currentThread().getName() + " 卖出第:" + i +"张票");
33                 condition.signal();
34                 flag3 = false;
35                 lock.unlock();
36             }
37         }, "窗口2");
38         t1.start();
39         t2.start();
40     }

 结果:

两个线程交替打印/卖票问题?(5种方法)

 

方法五(SynchronousQueue阻塞队列)
    解题思路

     定义一个阻塞队列,t2线程调用put或tranfer往队列里放数据时,会阻塞,所以t1先执行,取走之前放进来的奇数张票,并打印,然后将偶数put或tranfer到队列,t1阻塞,t2继续执行,如此反复执行。

    代码实现:

 1 //方法五(SynchronousQueue阻塞队列)
 2     public void test5(){
 3         //定义奇偶数数组
 4         int[] even = new int[50];
 5         int[] odd =  new int[50];
 6         int a =0;
 7         for(int i=0;i<100;i++){
 8             if(i%2==0){
 9                 odd[a]=i+1; //偶数 2 4 6 8 10
10                 a++;
11             }else{
12                 even[a-1]=i+1; //奇数 1 3 5 7 9
13             }
14         }
15         SynchronousQueue<Integer> queue=new SynchronousQueue<>();
16         new Thread(()->{
17             try{
18                 for(int i:even){
19                     System.out.println(Thread.currentThread().getName() + " 卖出第:" + queue.take() +"张票");
20                     queue.put(i);
21                 }
22             }
23             catch(Exception e){
24                 e.printStackTrace();
25             }
26         },"线程A").start();
27         new Thread(()->{
28             try{
29                 for(int i:odd){
30                     queue.put(i);
31                     System.out.println(Thread.currentThread().getName() + " 卖出第:" + queue.take()  +"张票");
32                 }
33             }
34             catch(Exception e){
35                 e.printStackTrace();
36             }
37         },"线程B").start();
38     }
SynchronousQueue是一个没有容量的队列,它的put操作和take操作之间是相互依赖的,即put操作必须在take操作准备好时才能将元素“推”过去,反之take操作也必须在put操作准备推元素的时候才能获取到元素。有人可能会说只有1个容量大小的BlockingQueue也能实现该操作,但是它们之间有着本质的不同
1、SynchronousQueue在put时,如果另一个线程没有执行take操作,put线程会一直阻塞;而BlockingQueue在put一个元素时,第一次是不会阻塞的,只有第二次因为容量满了put操作才阻塞,而SynchronousQueue在第一次就阻塞;
2、从第1点就可以看出SynchronousQueue容量为0,而BlockingQueue至少有容纳1个元素的空间。

 结果:

 两个线程交替打印/卖票问题?(5种方法)

 

 至此:5中交替打印卖票的方法就总结完了!

 

程序员灯塔
转载请注明原文链接:两个线程交替打印/卖票问题?(5种方法)
喜欢 (0)