python两个线程交替打印_三线程按顺序交替打印ABC的四种方法
建立三個(gè)線程A、B、C，A線程打印10次字母A，B線程打印10次字母B,C線程打印10次字母C，但是要求三個(gè)線程同時(shí)運(yùn)行，并且實(shí)現(xiàn)交替打印，即按照ABCABCABC的順序打印。
二、Synchronized同步法
1、基本思路
使用同步塊和wait、notify的方法控制三個(gè)線程的執(zhí)行次序。具體方法如下：從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環(huán)執(zhí)行三個(gè)線程。為了控制線程執(zhí)行的順序，那么就必須要確定喚醒、等待的順序，所以每一個(gè)線程必須同時(shí)持有兩個(gè)對象鎖，才能進(jìn)行打印操作。一個(gè)對象鎖是prev，就是前一個(gè)線程所對應(yīng)的對象鎖，其主要作用是保證當(dāng)前線程一定是在前一個(gè)線程操作完成后(即前一個(gè)線程釋放了其對應(yīng)的對象鎖)才開始執(zhí)行。還有一個(gè)鎖就是自身對象鎖。主要的思想就是，為了控制執(zhí)行的順序，必須要先持有prev鎖(也就前一個(gè)線程要釋放其自身對象鎖)，然后當(dāng)前線程再申請自己對象鎖，兩者兼?zhèn)鋾r(shí)打印。之后首先調(diào)用self.notify()喚醒下一個(gè)等待線程(注意notify不會立即釋放對象鎖，只有等到同步塊代碼執(zhí)行完畢后才會釋放)，再調(diào)用prev.wait()立即釋放prev對象鎖，當(dāng)前線程進(jìn)入休眠，等待其他線程的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) {// 多線程并發(fā)，不能用if，必須使用whil循環(huán)
synchronized (prev) { // 先獲取 prev 鎖
synchronized (self) {// 再獲取 self 鎖
System.out.print(name);//打印
count--;
self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時(shí)self鎖并未立即釋放。
}
//此時(shí)執(zhí)行完self的同步塊，這時(shí)self鎖才釋放。
try {
prev.wait(); // 立即釋放 prev鎖，當(dāng)前線程休眠，等待喚醒
/**
* JVM會在wait()對象鎖的線程中隨機(jī)選取一線程，賦予其對象鎖，喚醒線程，繼續(xù)執(zhí)行。
*/
} 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三個(gè)對象鎖，分別對應(yīng)A、B、C三個(gè)線程。A線程最先運(yùn)行，A線程按順序申請c,a對象鎖，打印操作后按順序釋放a,c對象鎖，并且通過notify操作喚醒線程B。線程B首先等待獲取A鎖，再申請B鎖，后打印B，再釋放B，A鎖，喚醒C。線程C等待B鎖，再申請C鎖，后打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什么問題，但如果你仔細(xì)想一下，就會發(fā)現(xiàn)有問題，就是初始條件，三個(gè)線程必須按照A,B,C的順序來啟動，但是這種假設(shè)依賴于JVM中線程調(diào)度、執(zhí)行的順序。
原實(shí)現(xiàn)存在的問題：
如果把上述代碼放到eclipse上運(yùn)行，可以發(fā)現(xiàn)程序雖然完成了交替打印ABC十次的任務(wù)，但是打印完畢后無法自動結(jié)束線程。這是為什么呢？原因就在于下面這段代碼：
try {
prev.wait(); // 立即釋放 prev鎖，當(dāng)前線程休眠，等待喚醒
/**
* JVM會在wait()對象鎖的線程中隨機(jī)選取一線程，賦予其對象鎖，喚醒線程，繼續(xù)執(zhí)行。
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
prev.wait(); 是釋放prev鎖并休眠線程，等待喚醒。在最后一次打印完畢后，因?yàn)閏ount為0，無法進(jìn)入while循環(huán)的同步代碼塊，自然就不會觸發(fā)notifyAll操作。這樣一來，執(zhí)行完打印操作后，線程就一直處于休眠待喚醒狀態(tài)，導(dǎo)致線程無法正常結(jié)束。
改進(jìn)實(shí)現(xiàn)：
我們找到了了問題的原因，解決起來就簡單了。最直接的思路就是在最后一次打印操作時(shí)在不休眠線程的情況下釋放對象鎖，這可以通過notifyAll操作實(shí)現(xiàn)。于是改進(jìn)的代碼如下：
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) {// 多線程并發(fā)，不能用if，必須使用whil循環(huán)
synchronized (prev) { // 先獲取 prev 鎖
synchronized (self) {// 再獲取 self 鎖
System.out.print(name);// 打印
count--;
self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時(shí)self鎖并未立即釋放。
}
// 此時(shí)執(zhí)行完self的同步塊，這時(shí)self鎖才釋放。
try {
if (count == 0) {// 如果count==0,表示這是最后一次打印操作，通過notifyAll操作釋放對象鎖。
prev.notifyAll();
} else {
prev.wait(); // 立即釋放 prev鎖，當(dāng)前線程休眠，等待喚醒
}
} 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上運(yùn)行，就可以自動結(jié)束線程了。從這里，我們也可以得出wait和notify操作的異同：
wait() 與 notify/notifyAll() 是Object類的方法，在執(zhí)行兩個(gè)方法時(shí)，要先獲得鎖。
當(dāng)線程執(zhí)行wait()時(shí)，會把當(dāng)前的鎖釋放，然后讓出CPU，進(jìn)入等待狀態(tài)。
當(dāng)執(zhí)行notify/notifyAll方法時(shí)，會喚醒一個(gè)處于等待該 對象鎖 的線程，然后繼續(xù)往下執(zhí)行，直到執(zhí)行完退出對象鎖鎖住的區(qū)域(synchronized修飾的代碼塊)后再釋放鎖。
從這里可以看出，notify/notifyAll()執(zhí)行后，并不立即釋放鎖，而是要等到執(zhí)行完臨界區(qū)中代碼后，再釋放。所以在實(shí)際編程中，我們應(yīng)該盡量在線程調(diào)用notify/notifyAll()后，立即退出臨界區(qū)。即不要在notify/notifyAll()后面再寫一些耗時(shí)的代碼。
二、Lock鎖方法
1、基本思路
通過ReentrantLock我們可以很方便的進(jìn)行顯式的鎖操作，即獲取鎖和釋放鎖，對于同一個(gè)對象鎖而言，統(tǒng)一時(shí)刻只可能有一個(gè)線程拿到了這個(gè)鎖，此時(shí)其他線程通過lock.lock()來獲取對象鎖時(shí)都會被阻塞，直到這個(gè)線程通過lock.unlock()操作釋放這個(gè)鎖后，其他線程才能拿到這個(gè)鎖。
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) {// 多線程并發(fā)，不能用if，必須用循環(huán)測試等待條件，避免虛假喚醒
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) {
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) {
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是可重入鎖，它持有一個(gè)鎖計(jì)數(shù)器，當(dāng)已持有鎖的線程再次獲得該鎖時(shí)計(jì)數(shù)器值加1，每調(diào)用一次lock.unlock()時(shí)所計(jì)數(shù)器值減一，直到所計(jì)數(shù)器值為0，此時(shí)線程釋放鎖。示例如下：
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結(jié)合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()才能創(chuàng)建一個(gè)Condition。從上面的代碼可以看出，Synchronized能實(shí)現(xiàn)的通信方式，Condition都可以實(shí)現(xiàn)，功能類似的代碼寫在同一行中。這樣解題思路就和第一種方法基本一致，只是采用的方法不同。
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之前，當(dāng)前線程一直阻塞狀態(tài)
A.await(); // A釋放lock鎖
System.out.print("A");
count++;
B.signal(); // A執(zhí)行完喚醒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鎖，當(dāng)前面A線程執(zhí)行后會通過B.signal()喚醒該線程
System.out.print("B");
count++;
C.signal();// B執(zhí)行完喚醒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鎖，當(dāng)前面B線程執(zhí)行后會通過C.signal()喚醒該線程
System.out.print("C");
count++;
A.signal();// C執(zhí)行完喚醒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又稱信號量，是操作系統(tǒng)中的一個(gè)概念，在Java并發(fā)編程中，信號量控制的是線程并發(fā)的數(shù)量。
public Semaphore(int permits)
其中參數(shù)permits就是允許同時(shí)運(yùn)行的線程數(shù)目;
Semaphore是用來保護(hù)一個(gè)或者多個(gè)共享資源的訪問，Semaphore內(nèi)部維護(hù)了一個(gè)計(jì)數(shù)器，其值為可以訪問的共享資源的個(gè)數(shù)。一個(gè)線程要訪問共享資源，先獲得信號量，如果信號量的計(jì)數(shù)器值大于1，意味著有共享資源可以訪問，則使其計(jì)數(shù)器值減去1，再訪問共享資源。如果計(jì)數(shù)器值為0,線程進(jìn)入休眠。當(dāng)某個(gè)線程使用完共享資源后，釋放信號量，并將信號量內(nèi)部的計(jì)數(shù)器加1，之前進(jìn)入休眠的線程將被喚醒并再次試圖獲得信號量。
Semaphore使用時(shí)需要先構(gòu)建一個(gè)參數(shù)來指定共享資源的數(shù)量，Semaphore構(gòu)造完成后即是獲取Semaphore、共享資源使用完畢后釋放Semaphore。
Semaphore semaphore = new Semaphore(3,true);
semaphore.acquire();
//do something here
semaphore.release();
import java.util.concurrent.Semaphore;
public class ABC_Semaphore {
// 以A開始的信號量,初始信號量數(shù)量為1
private static Semaphore A = new Semaphore(1);
// B、C信號量,A完成后開始,初始信號數(shù)量為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獲取信號執(zhí)行,A信號量減1,當(dāng)A為0時(shí)將無法繼續(xù)獲得該信號量
System.out.print("A");
B.release();// B釋放信號，B信號量加1(初始為0)，此時(shí)可以獲取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();
}
}
總結(jié)
以上是生活随笔為你收集整理的python两个线程交替打印_三线程按顺序交替打印ABC的四种方法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 2016小米pay/Mi pay怎么设置
- 下一篇： python三维数据本地保存_如何将3D