Java Condition在线程之间进行切换

Bertha 。 2023-10-05 18:57 25阅读 0赞

package Condition;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    class RunnableThread implements Runnable {
    	Lock lock;
    	Condition condition1;
    	Condition condition2;
    	Condition condition3;
    	boolean isOnePrint = false;
    	boolean isTwoPrint = false;
    
    	public RunnableThread(Lock lock, Condition condition1, Condition condition2, Condition condition3) {
    		this.lock = lock;
    		this.condition1 = condition1;
    		this.condition2 = condition2;
    		this.condition3 = condition3;
    	}
    
    	@Override
    	public void run() {
    		if ("Thread-1".equals(Thread.currentThread().getName())) {
    			methodForT1();
    		} else if ("Thread-2".equals(Thread.currentThread().getName())) {
    			methodForT2();
    		} else {
    			methodForT3();
    		}
    	}
    
    	public void methodForT1() {
    		lock.lock();
    		try {
    			for (int i = 1; i <= 15; i += 3) {
    				if (!isOnePrint) {
    					condition2.signalAll();
    					System.out.println(Thread.currentThread().getName() + " Print = " + i);
    					Thread.sleep(1000);
    					isOnePrint = true;
    				} else {
    					i = i - 3;
    					condition1.await();
    				}
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} finally {
    			lock.unlock();
    		}
    	}
    
    	public void methodForT2() {
    		lock.lock();
    		try {
    			for (int i = 2; i <= 15; i += 3) {
    				if (isOnePrint) {
    					condition3.signalAll();
    					System.out.println(Thread.currentThread().getName() + " Print = " + i);
    					Thread.sleep(1000);
    					isOnePrint = false;
    					isTwoPrint = true;
    				} else {
    					i = i - 3;
    					condition2.await();
    				}
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} finally {
    			lock.unlock();
    		}
    	}
    
    	public void methodForT3() {
    		lock.lock();
    		try {
    			for (int i = 3; i <= 15; i += 3) {
    				if (isTwoPrint) {
    					condition1.signalAll();
    					System.out.println(Thread.currentThread().getName() + " Print = " + i);
    					Thread.sleep(1000);
    					isOnePrint = false;
    					isTwoPrint = false;
    				} else {
    					i = i - 3;
    					condition3.await();
    				}
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		} finally {
    			lock.unlock();
    		}
    	}
    }
    
    public class LockConditionTest {
    	public static void main(String[] args) {
    		Lock lock = new ReentrantLock();
    		Condition condition1 = lock.newCondition();
    		Condition condition2 = lock.newCondition();
    		Condition condition3 = lock.newCondition();
    		RunnableThread runnableObj = new RunnableThread(lock, condition1, condition2, condition3);
    		Thread t1 = new Thread(runnableObj, "Thread-1");
    		Thread t2 = new Thread(runnableObj, "Thread-2");
    		Thread t3 = new Thread(runnableObj, "Thread-3");
    		t2.start();
    		t1.start();
    		t3.start();
    	}
    }

输出：

Thread-1 Print = 1  
Thread-2 Print = 2  
Thread-3 Print = 3  
Thread-1 Print = 4  
Thread-2 Print = 5  
Thread-3 Print = 6  
Thread-1 Print = 7  
Thread-2 Print = 8  
Thread-3 Print = 9  
Thread-1 Print = 10  
Thread-2 Print = 11  
Thread-3 Print = 12  
Thread-1 Print = 13  
Thread-2 Print = 14  
Thread-3 Print = 15

因此，这是一个示例，其中三个线程交替使用条件接口打印数字。所有这三个线程共享  
*RunnableThread*的相同实例，并且使用C **ondition**接口在它们之间进行切换。我们也可以使用*wait（）*和*notify（）*来实现操作，但是在这种情况下（使用wait（），notify（）），我们必须放置很多标志来检查thread1是否完成了任务，然后类似地转到第二个线程对于thread2和thread3。通过使用**Condition**接口，我们只能使用要唤醒的线程来发信号（通过使用signal（）），但是在notify（）的情况下，当notify（）被调用时，它可以唤醒任何正在等待对象的线程，例如例如。如果有两个以上的线程正在等待对象获取锁，则在这种情况下，可以选择其中一个线程来访问共享资源。

因此，这一切都与Java中的Condition接口有关。