精选30+云产品,助力企业轻松上云!>>>
前言:
在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行,虽然说可以通过线程的优先权进行设置,但是他只是获取CUP执行权的概率高点,但是也不一定必须先执行。在这种情况下如何保证线程按照一定的顺序进行执行,今天就来一个大总结,分别介绍一下几种方式。
一、通过Object的wait和notify
二、通过Condition的awiat和signal
三、通过一个阻塞队列
四、通过两个阻塞队列
五、通过SynchronousQueue
六、通过线程池的Callback回调
七、通过同步辅助类CountDownLatch
八、通过同步辅助类CyclicBarrier
一、通过Object的wait和notify
写一个测试了Test,加上main方法,在写一个内部类Man进行测试。main方法如下,他进行创建两个线程,传进去Runnable对象。
public static boolean flag = false;public static int num = 0;public static void main(String[] args) {Man man = new Man();new Thread(() -> {man.getRunnable1();}).start();new Thread(() -> {man.getRunnable2();}).start();}
getRunnable1和getRunnable2分别表示两个需要执行的任务,在两个线程中进行,方法1用于数据的生产,方法二用于数据的获取,数据的初始值为num = 0,为了保证生产和获取平衡需要使用wait和notify方法,这两个方法的使用必须是要加锁的,因此使用synchronized进行加锁使用,为了演示这个效果,我们加上一个sleep方法模拟处理时间,如下:
public static class Man {public synchronized void getRunnable1() {for (int i = 0; i < 20; i++) {while (flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(\"生产出:\" + (++num) + \"个\");flag = true;notify();}}public synchronized void getRunnable2() {for (int i = 0; i < 20; i++) {while (!flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//模拟加载时间try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(\"取出出:\" + (num--) + \"个\");System.out.println(\"------------------\");flag = false;notify();}}}
分析它的加载流程,从方法1进行分析,由于flag的初始条件为false,所以方法1不进入等待,直接进行生产,生产完成成之后,更新flag的值为true,同时notify下一个方法2的wait方法,使其变为唤醒状态。这时候由于方法1加锁了,无法执行方法1其他部分,当方法1执行完毕,方法1才有可能执行,但是方法1的flag已经为true,进入到wait里面又处于阻塞状态,所以这时候只能执行方法2了。由于方法2被唤醒了,阻塞解除,接下来就获取数据,当获取完毕又再次让flag变为false,notify方法1解除阻塞,再次执行方法1,就这样不断的循环,保证了不同线程的有序执行,直到程序终止。
运行效果如下:
二、通过Condition的awiat和signal
上面第一个的实现是一个阻塞,一个等待的方式保证线程有序的执行,但是不能进行两个线程之间进行通信,而接下来介绍的Condition就具备这样的功能。要获取Condition对象首先先得获取Lock对象,他是在jdk1.5之后增加的,比synchronized性能更好的一种锁机制。和上面的类似,拷贝一份代码,看看main方法:
public static boolean flag = false;public static int num = 0;public static void main(String[] args) {Man man = new Man();new Thread(() -> {man.getRunnable1();}).start();new Thread(() -> {man.getRunnable2();}).start();}
情况和第一个实现方法分析一致,这里不重复了。主要看内部类Man中的方法1和方法2。先手创建锁对象,把synchronized改为使用Lock加锁,其次通过Lock创建Condition对象,替换掉Object类的wait方法为Condition的await方法,最后换掉notify方法为signal方法即可,执行原理和上面分析一致,代码如下:
public static class Man {public static ReentrantLock lock = new ReentrantLock();public static Condition condition = lock.newCondition();public void getRunnable1() {lock.lock();try {for (int i = 0; i < 20; i++) {while (flag) {try {condition.await();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(\"生产出:\" + (++num) + \"个\");flag = true;condition.signal();}} finally {lock.lock();}}public void getRunnable2() {lock.lock();try {for (int i = 0; i < 20; i++) {while (!flag) {try {condition.await();} catch (InterruptedException e) {e.printStackTrace();}}try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(\"取出出:\" + (num--) + \"个\");System.out.println(\"------------------\");flag = false;condition.signal();}} finally {lock.unlock();}}}
执行结果如下:
这是我的iOS开发交流群:519832104不管你是小白还是大牛欢迎入驻,可以一起分享经验,讨论技术,共同学习成长!
另附上一份各好友收集的大厂面试题,需要iOS开发学习资料、面试真题,进群即可自行下载!点击此处,立即与iOS大牛交流学习
三、通过一个阻塞队列
上面的两个方法实现起来代码比较繁琐,如果通过阻塞队列来实现会更加简洁,这里采用常用的容量为64的ArrayBlockingQueue来实现。main方法如下:
public static void main(String[] args) {Man man = new Man();new Thread(() -> {man.getRunnable1();}).start();new Thread(() -> {man.getRunnable2();}).start();}
主要来看Man中的方法1和方法2,方法1中生产数据,这里把生产的数据存进队列里面,同时方法2进行取数据,如果方法1放满了或者方法2取完了就会被阻塞住,等待方法1生产好了或者方法2取出了,然后再进行。代码如下:
public static class Man {ArrayBlockingQueue queue = new ArrayBlockingQueue<Integer>(64);public void getRunnable1() {for (int i = 0; i < 8; i++) {System.out.println(\"生产出:\" + i + \"个\");try {queue.put(i);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(\"---------------生产完毕-----------------\");}public void getRunnable2() {for (int i = 0; i < 8; i++) {try {int num = (int) queue.take();System.out.println(\"取出出:\" + num);} catch (InterruptedException e) {e.printStackTrace();}}}}
很明显使用阻塞队列代码精炼了很多,在这还可以发现这个阻塞队列是具有缓存功能的,想很多Android中网络访问框架内部就是使用这个进行缓存的,例如Volley、Okhttp等等。
运行效果如下:
四、通过两个阻塞队列
使用一个阻塞队列能够实现线程同步的功能,两个阻塞队列也可以实现线程同步。原理是ArrayBlockingQueue他是具有容量的,如果把他的容量定位1则意味着他只能放进去一个元素,第二个方进行就会就会被阻塞。按照这个原理进行来实现,定义两个容量为1的阻塞队列ArrayBlockingQueue,一个存放数据,另一个用于控制次序。main方法和上面一致,主要来看看Man类中的两个方法:
static class Man {//数据的存放ArrayBlockingQueue queue1 = new ArrayBlockingQueue<Integer>(1);//用于控制程序的执行ArrayBlockingQueue queue2 = new ArrayBlockingQueue<Integer>(1);{try {//queue2放进去一个元素,getRunnable2阻塞queue2.put(22222);} catch (InterruptedException e) {e.printStackTrace();}}public void getRunnable1() {new Thread(() -> {for (int j = 0; j < 20; j++) {try {//queue1放进一个元素,getRunnable1阻塞queue1.put(j);System.out.println(\"存放 线程名称:\" + Thread.currentThread().getName() + \"-数据为-\" + j);} catch (InterruptedException e) {e.printStackTrace();}try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}try {//queue2取出元素,getRunnable2进入queue2.take();} catch (InterruptedException e) {e.printStackTrace();}}}).start();}public void getRunnable2() {new Thread(() -> {for (int j = 0; j < 20; j++) {try {//queue2放进一个元素,getRunnable2阻塞queue2.put(22222);} catch (InterruptedException e) {e.printStackTrace();}try {//queue1放进一个元素,getRunnable1进入int i = (int) queue1.take();System.out.println(\"获取 线程名称:\" + Thread.currentThread().getName() + \"-数据为-\" + i);} catch (InterruptedException e) {e.printStackTrace();}}}).start();}}
再次提醒queue2用于控制程序的执行次序,并无实际含义。最后看看运行效果,存一个、取一个很清晰,如下:
五、通过SynchronousQueue
SynchronousQueue不同于一般的数据等线程,而是线程等待数据,他是一个没有数据缓冲的BlockingQueue,生产者线程对其的插入操作put必须等待消费者的移除操作take,反过来也一样。通过这一特性来实现一个多线程同步问题的解决方案,代码如下:
/*** 使用阻塞队列SynchronousQueue* offer将数据插入队尾* take取出数据,如果没有则阻塞,直到有数据在获取到*/public static void test() {SynchronousQueue queue = new SynchronousQueue();ExecutorService executorService = Executors.newSingleThreadExecutor();executorService.execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(5000);queue.offer(9);} catch (InterruptedException e) {e.printStackTrace();}}});try {int take = (int) queue.take();System.out.println(take);} catch (InterruptedException e) {e.printStackTrace();}}
子线程中进行设置数据,而主线程获取数据,如果子线程没执行完毕,子线程没有执行完毕主线程就会被阻塞住不能执行下一步。
六、通过线程池的Callback回调
在线程的创建中,有一种创建方法可以返回线程结果,就是callback,他能返回线程的执行结果,通过子线程返回的结果进而在主线程中进行操作,也是一种同步方法,这种同步在Android中特别适用,例如Android中的AsyncTask源码中任务的创建部分。代码如下:
private static void test() {ExecutorService executorService = Executors.newFixedThreadPool(5);Future<Boolean> submit = executorService.submit(new Callable<Boolean>() {@Overridepublic Boolean call() throws Exception {return false;}});try {if (submit.get()) {System.out.println(true);} else {System.out.println(false);}} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
七、通过同步辅助类CountDownLatch
CountDownLatch是一个同步的辅助类,允许一个或多个线程,等待其他一组线程完成操作,再继续执行。他类实际上是使用计数器的方式去控制的,在创建的时候传入一个int数值每当我们调用countDownt()方法的时候就使得这个变量的值减1,而对于await()方法则去判断这个int的变量的值是否为0,是则表示所有的操作都已经完成,否则继续等待。可以理解成倒计时锁。
public class Test7 {public static void main(String[] args) {//启动两个线程,分别执行完毕之后再执行主线程CountDownLatch countDownLatch = new CountDownLatch(2);//线程1执行Thread thread1 = new Thread(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + \"线程执行完毕\");countDownLatch.countDown();});//线程2执行Thread thread2 = new Thread(() -> {System.out.println(Thread.currentThread().getName() + \"线程执行完毕\");countDownLatch.countDown();});thread1.start();thread2.start();try {countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}//执行主线程System.out.println(\"主线程执行完毕\");}}
结果如下:
八、通过同步辅助类CyclicBarrier
CyclicBarrier是一个同步的辅助类,和上面的CountDownLatch比较类似,不同的是他允许一组线程相互之间等待,达到一个共同点,再继续执行。可看成是个障碍,所有的线程必须到齐后才能一起通过这个障碍。
public class Test8 {public static void main(String[] args) {//启动两个线程,分别执行完毕之后再执行主线程CyclicBarrier barrier = new CyclicBarrier(2, () -> {//执行主线程System.out.println(\"主线程执行完毕\");});//线程1执行Thread thread1 = new Thread(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + \"线程执行完毕\");try {barrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}});//线程2执行Thread thread2 = new Thread(() -> {System.out.println(Thread.currentThread().getName() + \"线程执行完毕\");try {barrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}});thread1.start();thread2.start();}}
运行结果: