单屏网站设计,工业软件开发技术,wordpress返利主题,自己做网站需要做服务器建立三个线程A、B、C#xff0c;A线程打印10次字母A#xff0c;B线程打印10次字母B,C线程打印10次字母C#xff0c;但是要求三个线程同时运行#xff0c;并且实现交替打印#xff0c;即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、noti…建立三个线程A、B、CA线程打印10次字母AB线程打印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;}Overridepublic 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 {prev.wait(); // 立即释放 prev锁当前线程休眠等待唤醒/*** JVM会在wait()对象锁的线程中随机选取一线程赋予其对象锁唤醒线程继续执行。*/} 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再释放BA锁唤醒C。线程C等待B锁再申请C锁后打印C再释放C,B锁唤醒A。看起来似乎没什么问题但如果你仔细想一下就会发现有问题就是初始条件三个线程必须按照A,B,C的顺序来启动但是这种假设依赖于JVM中线程调度、执行的顺序。原实现存在的问题如果把上述代码放到eclipse上运行可以发现程序虽然完成了交替打印ABC十次的任务但是打印完毕后无法自动结束线程。这是为什么呢原因就在于下面这段代码try {prev.wait(); // 立即释放 prev锁当前线程休眠等待唤醒/*** JVM会在wait()对象锁的线程中随机选取一线程赋予其对象锁唤醒线程继续执行。*/} catch (InterruptedException e) {e.printStackTrace();}prev.wait(); 是释放prev锁并休眠线程等待唤醒。在最后一次打印完毕后因为count为0无法进入while循环的同步代码块自然就不会触发notifyAll操作。这样一来执行完打印操作后线程就一直处于休眠待唤醒状态导致线程无法正常结束。改进实现我们找到了了问题的原因解决起来就简单了。最直接的思路就是在最后一次打印操作时在不休眠线程的情况下释放对象锁这可以通过notifyAll操作实现。于是改进的代码如下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;}Overridepublic 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) {// 如果count0,表示这是最后一次打印操作通过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(100);// 保证初始ABC的启动顺序new Thread(pb).start();Thread.sleep(100);new Thread(pc).start();Thread.sleep(100);}}上述代码放到eclipse上运行就可以自动结束线程了。从这里我们也可以得出wait和notify操作的异同wait() 与 notify/notifyAll() 是Object类的方法在执行两个方法时要先获得锁。当线程执行wait()时会把当前的锁释放然后让出CPU进入等待状态。当执行notify/notifyAll方法时会唤醒一个处于等待该 对象锁 的线程然后继续往下执行直到执行完退出对象锁锁住的区域(synchronized修饰的代码块)后再释放锁。从这里可以看出notify/notifyAll()执行后并不立即释放锁而是要等到执行完临界区中代码后再释放。所以在实际编程中我们应该尽量在线程调用notify/notifyAll()后立即退出临界区。即不要在notify/notifyAll()后面再写一些耗时的代码。二、Lock锁方法1、基本思路通过ReentrantLock我们可以很方便的进行显式的锁操作即获取锁和释放锁对于同一个对象锁而言统一时刻只可能有一个线程拿到了这个锁此时其他线程通过lock.lock()来获取对象锁时都会被阻塞直到这个线程通过lock.unlock()操作释放这个锁后其他线程才能拿到这个锁。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 {Overridepublic 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 {Overridepublic void run() {for (int i 0; i 10;) {try {lock.lock();while (state % 3 1) {System.out.print(B);state;i;}} finally {lock.unlock();// unlock()操作必须放在finally块中}}}}static class ThreadC extends Thread {Overridepublic void run() {for (int i 0; i 10;) {try {lock.lock();while (state % 3 2) {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是可重入锁它持有一个锁计数器当已持有锁的线程再次获得该锁时计数器值加1每调用一次lock.unlock()时所计数器值减一直到所计数器值为0此时线程释放锁。示例如下import java.util.concurrent.locks.ReentrantLock;public class ReentrantLockTest {private ReentrantLock lock new ReentrantLock();public void testReentrantLock() {// 线程获得锁lock.lock();try {System.out.println(Thread.currentThread().getName() get lock);long beginTime System.currentTimeMillis();while (System.currentTimeMillis() - beginTime 100) {}//线程再次获得该锁(可重入)lock.lock();try {System.out.println(Thread.currentThread().getName() get lock again);long beginTime2 System.currentTimeMillis();while (System.currentTimeMillis() - beginTime2 100) {}} finally {// 线程第一次释放锁lock.unlock();System.out.println(Thread.currentThread().getName() release lock);}} finally {// 线程再次释放锁lock.unlock();System.out.println(Thread.currentThread().getName() release lock again);}}public static void main(String[] args) {final ReentrantLockTest test new ReentrantLockTest();Thread thread new Thread(new Runnable() {public void run() {test.testReentrantLock();}}, A);thread.start();}}三、ReentrantLock结合Condition1、基本思路与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都可以实现功能类似的代码写在同一行中。这样解题思路就和第一种方法基本一致只是采用的方法不同。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 {Overridepublic 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 {Overridepublic 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 {Overridepublic void run() {try {lock.lock();for (int i 0; i 10; i) {while (count % 3 ! 2)C.await();// C释放lock锁当前面B线程执行后会通过C.signal()唤醒该线程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(3,true);semaphore.acquire();//do something heresemaphore.release();import java.util.concurrent.Semaphore;public class ABC_Semaphore {// 以A开始的信号量,初始信号量数量为1private static Semaphore A new Semaphore(1);// B、C信号量,A完成后开始,初始信号数量为0private static Semaphore B new Semaphore(0);private static Semaphore C new Semaphore(0);static class ThreadA extends Thread {Overridepublic 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 {Overridepublic 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 {Overridepublic 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();}}
