JAVA实现多个线程顺序执行的几种方式 |
您所在的位置：网站首页 › java多线程获取结果怎么写 › JAVA实现多个线程顺序执行的几种方式 |
JAVA实现多个线程顺序执行的几种方式
|
题目描述：如何保证多个线程的顺序执行？
1、join方式实现
join方式即使用Thread.join方法来实现。Thread.join含义当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说，就是线程没有执行完之前，会一直阻塞在join方法处。 join方式实现方式存在两种：主线程join和执行线程join。下面我们依次来分析一下： 1.主线程join
上面源码就是主线程join的实现方式，其原理就是保证执行线程执行完毕再start后续线程，从而实现多个线程的顺序执行。 2.执行线程join
上面源码就是执行线程join的实现方式，其原理就是通过传入beforeThread（在这个线程执行前需要执行完的线程对象）来保证多个线程顺序执行。 2、CountDownLatch： 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。 public static void main(String[] args) { final CountDownLatch countDownLatch = new CountDownLatch(2); System.out.println("开始"); new Thread(() -> { System.out.println("A"); countDownLatch.countDown(); }).start(); new Thread(() -> { System.out.println("B"); countDownLatch.countDown(); }).start(); countDownLatch.await(); System.out.println("结束"); } 3、使用线程池：该线程池类似于单线程执行，所以先执行完前一个任务后，再顺序执行下一个任务。 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行 public static void main(String[] args) { Thread t1 = new Thread(() -> System.out.println("线程1"), "线程1"); Thread t2 = new Thread(() -> System.out.println("线程2"), "线程2"); Thread t3 = new Thread(() -> System.out.println("线程3")); ExecutorService executor = Executors.newSingleThreadExecutor(); // 将线程依次加入到线程池中 executor.submit(t1); executor.submit(t2); executor.submit(t3); // 及时将线程池关闭 executor.shutdown(); } 4、CompletableFuture public static void main(String[] args) { Thread t1 = new Thread(() -> System.out.println("线程1"), "线程1"); Thread t2 = new Thread(() -> System.out.println("线程2"), "线程2"); Thread t3 = new Thread(() -> System.out.println("线程3")); CompletableFuture.runAsync(() -> t1.start()) .thenRun(() -> t2.start()) .thenRun(() -> t3.start()); } 题目描述：建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。 一Synchronized同步法 1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能进行打印操作。一个对象锁是prev，就是前一个线程所对应的对象锁，其主要作用是保证当前线程一定是在前一个线程操作完成后（即前一个线程释放了其对应的对象锁）才开始执行。还有一个锁就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁（也就前一个线程要释放其自身对象锁），然后当前线程再申请自己对象锁，两者兼备时打印。之后首先调用self.notify()唤醒下一个等待线程（注意notify不会立即释放对象锁，只有等到同步块代码执行完毕后才会释放），再调用prev.wait()立即释放prev对象锁，当前线程进入休眠，等待其他线程的notify操作再次唤醒。 public class ABC_Synch { public static class ThreadPrinter implements Runnable { private String name; private Object prev; private Object self; private ThreadPrinter(String name, Object prev, Object self) { this.name = name; this.prev = prev; this.self = self; } @Override public void run() { int count = 10; while (count > 0) {// 多线程并发，不能用if，必须使用whil循环 synchronized (prev) { // 先获取 prev 锁 synchronized (self) {// 再获取 self 锁 System.out.print(name);// 打印 count--; self.notifyAll();// 唤醒其他线程竞争self锁，注意此时self锁并未立即释放。 } // 此时执行完self的同步块，这时self锁才释放。 try { if (count == 0) {// 如果count==0,表示这是最后一次打印操作，通过notifyAll操作释放对象锁。 prev.notifyAll(); } else { prev.wait(); // 立即释放 prev锁，当前线程休眠，等待唤醒 } } catch (InterruptedException e) { e.printStackTrace(); } } } } } public static void main(String[] args) throws Exception { Object a = new Object(); Object b = new Object(); Object c = new Object(); ThreadPrinter pa = new ThreadPrinter("A", c, a); ThreadPrinter pb = new ThreadPrinter("B", a, b); ThreadPrinter pc = new ThreadPrinter("C", b, c); new Thread(pa).start(); Thread.sleep(10);// 保证初始ABC的启动顺序 new Thread(pb).start(); Thread.sleep(10); new Thread(pc).start(); Thread.sleep(10); } }可以看到程序一共定义了a,b,c三个对象锁，分别对应A、B、C三个线程。A线程最先运行，A线程按顺序申请c,a对象锁，打印操作后按顺序释放a,c对象锁，并且通过notify操作唤醒线程B。线程B首先等待获取A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C。线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程必须按照A,B,C的顺序来启动，但是这种假设依赖于JVM中线程调度、执行的顺序。 二、Lock锁方法 1、基本思路通过ReentrantLock我们可以很方便的进行显式的锁操作，即获取锁和释放锁，对于同一个对象锁而言，统一时刻只可能有一个线程拿到了这个锁，此时其他线程通过lock.lock()来获取对象锁时都会被阻塞，直到这个线程通过lock.unlock()操作释放这个锁后，其他线程才能拿到这个锁。 2、代码 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ABC_Lock { private static Lock lock = new ReentrantLock();// 通过JDK5中的Lock锁来保证线程的访问的互斥 private static int state = 0;//通过state的值来确定是否打印 static class ThreadA extends Thread { @Override public void run() { for (int i = 0; i < 10;) { try { lock.lock(); while (state % 3 == 0) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒 System.out.print("A"); state++; i++; } } finally { lock.unlock();// unlock()操作必须放在finally块中 } } } } static class ThreadB extends Thread { @Override public void run() { for (int i = 0; i < 10;) { try { lock.lock(); while (state % 3 == 1) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒 System.out.print("B"); state++; i++; } } finally { lock.unlock();// unlock()操作必须放在finally块中 } } } } static class ThreadC extends Thread { @Override public void run() { for (int i = 0; i < 10;) { try { lock.lock(); while (state % 3 == 2) {// 多线程并发，不能用if，必须用循环测试等待条件，避免虚假唤醒 System.out.print("C"); state++; i++; } } finally { lock.unlock();// unlock()操作必须放在finally块中 } } } } public static void main(String[] args) { new ThreadA().start(); new ThreadB().start(); new ThreadC().start(); } } 三、ReentrantLock结合Condition 1、基本思路与ReentrantLock搭配的通行方式是Condition，如下： private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); condition.await();//this.wait(); condition.signal();//this.notify(); condition.signalAll();//this.notifyAll();Condition是被绑定到Lock上的，必须使用lock.newCondition()才能创建一个Condition。从上面的代码可以看出，Synchronized能实现的通信方式，Condition都可以实现，功能类似的代码写在同一行中。这样解题思路就和第一种方法基本一致，只是采用的方法不同。 2、代码 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ABC_Condition { private static Lock lock = new ReentrantLock(); private static Condition A = lock.newCondition(); private static Condition B = lock.newCondition(); private static Condition C = lock.newCondition(); private static int count = 0; static class ThreadA extends Thread { @Override public void run() { try { lock.lock(); for (int i = 0; i < 10; i++) { while (count % 3 != 0)//注意这里是不等于0，也就是说在count % 3为0之前，当前线程一直阻塞状态 A.await(); // A释放lock锁 System.out.print("A"); count++; B.signal(); // A执行完唤醒B线程 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } static class ThreadB extends Thread { @Override public void run() { try { lock.lock(); for (int i = 0; i < 10; i++) { while (count % 3 != 1) B.await();// B释放lock锁，当前面A线程执行后会通过B.signal()唤醒该线程 System.out.print("B"); count++; C.signal();// B执行完唤醒C线程 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } static class ThreadC extends Thread { @Override public void run() { try { lock.lock(); for (int i = 0; i < 10; i++) { while (count % 3 != 2) C.await();// C释放lock锁 System.out.print("C"); count++; A.signal();// C执行完唤醒A线程 } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } public static void main(String[] args) throws InterruptedException { new ThreadA().start(); new ThreadB().start(); new ThreadC().start(); } } 四、Semaphore信号量方式 1、基本思路Semaphore又称信号量，是操作系统中的一个概念，在Java并发编程中，信号量控制的是线程并发的数量。 public Semaphore(int permits)其中参数permits就是允许同时运行的线程数目; Semaphore是用来保护一个或者多个共享资源的访问，Semaphore内部维护了一个计数器，其值为可以访问的共享资源的个数。一个线程要访问共享资源，先获得信号量，如果信号量的计数器值大于1，意味着有共享资源可以访问，则使其计数器值减去1，再访问共享资源。如果计数器值为0,线程进入休眠。当某个线程使用完共享资源后，释放信号量，并将信号量内部的计数器加1，之前进入休眠的线程将被唤醒并再次试图获得信号量。 Semaphore使用时需要先构建一个参数来指定共享资源的数量，Semaphore构造完成后即是获取Semaphore、共享资源使用完毕后释放Semaphore。 Semaphore semaphore = new Semaphore(10,true); semaphore.acquire(); //do something here semaphore.release(); 2、代码 import java.util.concurrent.Semaphore; public class ABC_Semaphore { // 以A开始的信号量,初始信号量数量为1 private static Semaphore A = new Semaphore(1); // B、C信号量,A完成后开始,初始信号数量为0 private static Semaphore B = new Semaphore(0); private static Semaphore C = new Semaphore(0); static class ThreadA extends Thread { @Override public void run() { try { for (int i = 0; i < 10; i++) { A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量 System.out.print("A"); B.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量 } } catch (InterruptedException e) { e.printStackTrace(); } } } static class ThreadB extends Thread { @Override public void run() { try { for (int i = 0; i < 10; i++) { B.acquire(); System.out.print("B"); C.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } } static class ThreadC extends Thread { @Override public void run() { try { for (int i = 0; i < 10; i++) { C.acquire(); System.out.println("C"); A.release(); } } catch (InterruptedException e) { e.printStackTrace(); } } } public static void main(String[] args) throws InterruptedException { new ThreadA().start(); new ThreadB().start(); new ThreadC().start(); } }参考：多线程交替打印ABC的多种实现方法_多线程打印abc_想作会飞的鱼的博客-CSDN博客 百度安全验证 https://www.cnblogs.com/csnjava/p/17242714.html |
【本文地址】
今日新闻 |
推荐新闻 |