資訊專欄INFORMATION COLUMN
摘要：問題的描述啟動個線程打印遞增的數字線程先打印然后是線程打印然后是線程打印接著再由線程打印以此類推直到打印到程序的輸出結果應該為線程線程線程線程線程線程線程線程線程線程線程線程線程線程線程代碼實現使用原始的定義線程組一二三線程運行狀態馬上執行
【問題的描述：
啟動3個線程打印遞增的數字, 線程1先打印1,2,3,4,5, 然后是線程2打印6,7,8,9,10, 然后是線程3打印11,12,13,14,15. 接著再由線程1打印16,17,18,19,20....以此類推, 直到打印到75. 程序的輸出結果應該為:
線程1: 1
線程1: 2
線程1: 3
線程1: 4
線程1: 5
線程2: 6
線程2: 7
線程2: 8
線程2: 9
線程2: 10
...
線程3: 71
線程3: 72
線程3: 73
線程3: 74
線程3: 75
import java.util.ArrayList;
import java.util.List;
/**
* Created by ibm on 2017/8/8.
*/
public class ClassicTest {
//使用原始的synchornized object.wait() object.notify()
public static void main(String[] args) {
//定義線程組
List threadGroups = new ArrayList<>();
Counter counter = new Counter();
MyThread t1 = new MyThread(1,"一",counter,threadGroups);
MyThread t2 = new MyThread(2,"二",counter,threadGroups);
MyThread t3 = new MyThread(2,"三",counter,threadGroups);
threadGroups.add(t1);
threadGroups.add(t2);
threadGroups.add(t3);
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
}
}
class MyThread implements Runnable{
//線程運行狀態 1馬上執行，2阻塞
public int status;
//線程名字
public String name;
//計數器
public Counter counter;
//線程組
public List threads = new ArrayList<>();
public MyThread(int status,String name,Counter counter,List threads){
this.status = status;
this.name = name;
this.counter = counter;
this.threads = threads;
}
@Override
public void run() {
System.out.println(name + " GET " + status);
synchronized (counter){
while (!counter.isEnd()){
//判斷是否該自己執行，切記使用while,因為如果在循環的等待過程中status有所變化，這里需要再次判斷
while (status != 1){
try {
counter.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for(int i = 0;i < 5 ;i ++){
System.out.println(name + ":" + counter.get());
counter.increase();
}
//狀態進入阻塞狀態，并設置下一個可以運行的線程
status = 2;
setNext();
counter.notifyAll();
System.out.println("----");
}
}
}
void setNext(){
//當前線程在線程組的索引
int index = 0;
for(index = 0;index < threads.size();index++){
if(name.equals(threads.get(index).name)){
break;
}
}
if(index == (threads.size() - 1)){
threads.get(0).status = 1;
}else {
threads.get(index + 1).status = 1;
}
}
}
class Counter{
int num = 1;
int end = 75;
public int get(){
return num;
}
public void increase(){
if(isEnd()){
System.out.println("num超過限制");
return;
}
num++;
}
public boolean isEnd(){
if(num >= end){
return true;
}
return false;
}
}
【后面兩種解法來源網絡：
1.使用synchronized關鍵字：
public class ClassicTest1 {
// n為即將打印的數字
private static int n = 1;
// state=1表示將由線程1打印數字, state=2表示將由線程2打印數字, state=3表示將由線程3打印數字
private static int state = 1;
public static void main(String[] args) {
final ClassicTest1 pn = new ClassicTest1();
new Thread(new Runnable() {
public void run() {
// 3個線程打印75個數字, 單個線程每次打印5個連續數字, 因此每個線程只需執行5次打印任務. 3*5*5=75
for (int i = 0; i < 5; i++) {
// 3個線程都使用pn對象做鎖, 以保證每個交替期間只有一個線程在打印
synchronized (pn) {
// 如果state!=1, 說明此時尚未輪到線程1打印, 線程1將調用pn的wait()方法, 直到下次被喚醒
while (state != 1)
try {
pn.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 當state=1時, 輪到線程1打印5次數字
for (int j = 0; j < 5; j++) {
// 打印一次后n自增
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
// 線程1打印完成后, 將state賦值為2, 表示接下來將輪到線程2打印
state = 2;
// notifyAll()方法喚醒在pn上wait的線程2和線程3, 同時線程1將退出同步代碼塊, 釋放pn鎖.
// 因此3個線程將再次競爭pn鎖
// 假如線程1或線程3競爭到資源, 由于state不為1或3, 線程1或線程3將很快再次wait, 釋放出剛到手的pn鎖.
// 只有線程2可以通過state判定, 所以線程2一定是執行下次打印任務的線程.
// 對于線程2來說, 獲得鎖的道路也許是曲折的, 但前途一定是光明的.
pn.notifyAll();
}
}
}
}, "線程1").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (pn) {
while (state != 2)
try {
pn.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
state = 3;
pn.notifyAll();
}
}
}
}, "線程2").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (pn) {
while (state != 3)
try {
pn.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
state = 1;
pn.notifyAll();
}
}
}
}, "線程3").start();
}
}
2.使用condition與lock
public class ClassicTest2 implements Runnable {
private int state = 1;
private int n = 1;
// 使用lock做鎖
private ReentrantLock lock = new ReentrantLock();
// 獲得lock鎖的3個分支條件
private Condition c1 = lock.newCondition();
private Condition c2 = lock.newCondition();
private Condition c3 = lock.newCondition();
@Override
public void run() {
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
try {
// 線程1獲得lock鎖后, 其他線程將無法進入需要lock鎖的代碼塊.
// 在lock.lock()和lock.unlock()之間的代碼相當于使用了synchronized(lock){}
lock.lock();
while (state != 1)
try {
// 線程1競爭到了lock, 但是發現state不為1, 說明此時還未輪到線程1打印.
// 因此線程1將在c1上wait
// 與解法一不同的是, 三個線程并非在同一個對象上wait, 也不由同一個對象喚醒
c1.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 如果線程1競爭到了lock, 也通過了state判定, 將執行打印任務
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
// 打印完成后將state賦值為2, 表示下一次的打印任務將由線程2執行
state = 2;
// 喚醒在c2分支上wait的線程2
c2.signal();
} finally {
// 打印任務執行完成后需要確保鎖被釋放, 因此將釋放鎖的代碼放在finally中
lock.unlock();
}
}
}
}, "線程1").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
try {
lock.lock();
while (state != 2)
try {
c2.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
state = 3;
c3.signal();
} finally {
lock.unlock();
}
}
}
}, "線程2").start();
new Thread(new Runnable() {
public void run() {
for (int i = 0; i < 5; i++) {
try {
lock.lock();
while (state != 3)
try {
c3.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()
+ ": " + n++);
}
System.out.println();
state = 1;
c1.signal();
} finally {
lock.unlock();
}
}
}
}, "線程3").start();
}
public static void main(String[] args) {
new ClassicTest2().run();
}
}
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/68067.html
摘要：大多數待遇豐厚的開發職位都要求開發者精通多線程技術并且有豐富的程序開發調試優化經驗，所以線程相關的問題在面試中經常會被提到。掌握了這些技巧，你就可以輕松應對多線程和并發面試了。進入等待通行準許時，所提供的對象。 最近看到網上流傳著，各種面試經驗及面試題，往往都是一大堆技術題目貼上去，而沒有答案。 不管你是新程序員還是老手，你一定在面試中遇到過有關線程的問題。Java語言一個重要的特點就...
摘要：相比與其他操作系統包括其他類系統有很多的優點，其中有一項就是，其上下文切換和模式切換的時間消耗非常少。因為多線程競爭鎖時會引起上下文切換。減少線程的使用。很多編程語言中都有協程。所以如何避免死鎖的產生，在我們使用并發編程時至關重要。 系列文章傳送門: Java多線程學習（一）Java多線程入門 Java多線程學習（二）synchronized關鍵字（1） java多線程學習（二）syn...
摘要：因為多線程競爭鎖時會引起上下文切換。減少線程的使用。舉個例子如果說服務器的帶寬只有，某個資源的下載速度是，系統啟動個線程下載該資源并不會導致下載速度編程，所以在并發編程時，需要考慮這些資源的限制。 最近私下做一項目，一bug幾日未解決，總惶恐。一日頓悟，bug不可怕，怕的是項目不存在bug,與其懼怕，何不與其剛正面。 系列文章傳送門: Java多線程學習（一）Java多線程入門 Jav...
摘要：學習編程的本最佳書籍這些書涵蓋了各個領域，包括核心基礎知識，集合框架，多線程和并發，內部和性能調優，設計模式等。擅長解釋錯誤及錯誤的原因以及如何解決簡而言之，這是學習中并發和多線程的最佳書籍之一。 showImg(https://segmentfault.com/img/remote/1460000018913016); 來源 | 愿碼(ChainDesk.CN)內容編輯 愿碼Slo...
摘要：并發編程的挑戰并發編程的目的是為了讓程序運行的更快，但是，并不是啟動更多的線程就能讓程序最大限度的并發執行。的實現原理與應用在多線程并發編程中一直是元老級角色，很多人都會稱呼它為重量級鎖。 并發編程的挑戰 并發編程的目的是為了讓程序運行的更快，但是，并不是啟動更多的線程就能讓程序最大限度的并發執行。如果希望通過多線程執行任務讓程序運行的更快，會面臨非常多的挑戰：（1）上下文切換（2）死...
閱讀 1668·2021-11-16 11:44
閱讀 2404·2021-10-11 11:07
閱讀 4064·2021-10-09 09:41
閱讀 673·2021-09-22 15:52
閱讀 3195·2021-09-09 09:33
閱讀 2712·2019-08-30 15:55
閱讀 2291·2019-08-30 15:55
閱讀 843·2019-08-30 15:55
