2. 程式人生 > >理解 JAVA多執行緒技術之詳解

理解 JAVA多執行緒技術之詳解

阿新 • • 發佈：2019-02-13

1.    虛假的多執行緒

    例1：

    public class TestThread
    {
    int i=0, j=0;
    public void go(int flag){
    while(true){
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    if(flag==0)

    i++;
    System.out.println("i=" + i);
    }
    else{
    j++;
    System.out.println("j=" + j);
    }
    }
    }
    public static void main(String[] args){
    new TestThread().go(0);
    new TestThread().go(1);
    }
    }
    上面程式的執行結果為：

    i=1
    i=2
    i=3
    。。。

    結果將一直打印出I的值。我們的意圖是當在while迴圈中呼叫sleep()時，另一個執行緒就將起動，打印出j的值，但結果卻並不是這樣。關於sleep()為什麼不會出現我們預想的結果，在下面將講到。

    2.    實現多執行緒

    通過繼承classThread或實現Runnable介面，我們可以實現多執行緒
    2.1    通過繼承classThread實現多執行緒

    classThread中有兩個最重要的函式run()和start()。

    1)    run()函式必須進行覆寫，把要在多個執行緒中並行處理的程式碼放到這個函式中。

    2)    雖然run()函式實現了多個執行緒的並行處理，但我們不能直接呼叫run()函式，而是通過呼叫start()函式來呼叫run()函式。在呼叫start()的時候，start()函式會首先進行與多執行緒相關的初始化（這也是為什麼不能直接呼叫run()函式的原因），然後再呼叫run()函式。

    例2：

    public class TestThread extends Thread{
    private static int threadCount = 0;
    private int threadNum = ++threadCount;
    private int i = 5;
    public void run(){
    while(true){
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    System.out.println("Thread " + threadNum + " = " + i);
    if(--i==0) return;
    }
    }
    public static void main(String[] args){
    for(int i=0; i<5; i++)

    new TestThread().start();
    }
    }
    執行結果為：

    Thread 1 = 5
    Thread 2 = 5
    Thread 3 = 5
    Thread 4 = 5
    Thread 5 = 5
    Thread 1 = 4
    Thread 2 = 4
    Thread 3 = 4
    Thread 4 = 4
    Thread 1 = 3
    Thread 2 = 3
    Thread 5 = 4
    Thread 3 = 3
    Thread 4 = 3
    Thread 1 = 2
    Thread 2 = 2
    Thread 5 = 3
    Thread 3 = 2
    Thread 4 = 2
    Thread 1 = 1
    Thread 2 = 1
    Thread 5 = 2
    Thread 3 = 1
    Thread 4 = 1
    Thread 5 = 1
    從結果可見，例2能實現多執行緒的並行處理。

    ＊＊：在上面的例子中，我們只用new產生Thread物件，並沒有用reference來記錄所產生的Thread物件。根據垃圾回收機制，當一個物件沒有被reference引用時，它將被回收。但是垃圾回收機制對Thread物件“不成立”。因為每一個Thread都會進行註冊動作，所以即使我們在產生Thread物件時沒有指定一個reference指向這個物件，實際上也會在某個地方有個指向該物件的reference，所以垃圾回收器無法回收它們。

    3)    通過Thread的子類產生的執行緒物件是不同物件的執行緒

    class TestSynchronized extends Thread{
    public TestSynchronized(String name){
    super(name);
    }
    public synchronized static void prt(){
    for(int i=10; i<20; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    public synchronized void run(){
    for(int i=0; i<3; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    }
    public class TestThread{
    public static void main(String[] args){
    TestSynchronized t1 = new TestSynchronized("t1");
    TestSynchronized t2 = new TestSynchronized("t2");
    t1.start();
    t1.start();//（1）

    //t2.start();（2）

    }
    }
    執行結果為：

    t1 : 0
    t1 : 1
    t1 : 2
    t1 : 0
    t1 : 1
    t1 : 2
    由於是同一個物件啟動的不同執行緒，所以run()函式實現了synchronized。如果去掉（2）的註釋，把程式碼（1）註釋掉，結果將變為：

    t1 : 0
    t2 : 0
    t1 : 1
    t2 : 1
    t1 : 2
    t2 : 2
    由於t1和t2是兩個物件，所以它們所啟動的執行緒可同時訪問run()函式。

    2.2    通過實現Runnable介面實現多執行緒

    如果有一個類，它已繼承了某個類，又想實現多執行緒，那就可以通過實現Runnable介面來實現。

    1)    Runnable介面只有一個run()函式。

    2)    把一個實現了Runnable介面的物件作為引數產生一個Thread物件，再呼叫Thread物件的start()函式就可執行並行操作。如果在產生一個Thread物件時以一個Runnable介面的實現類的物件作為引數，那麼在呼叫start()函式時，start()會呼叫Runnable介面的實現類中的run()函式。

    例3.1：

    public class TestThread implements Runnable{
    private static int threadCount = 0;
    private int threadNum = ++threadCount;
    private int i = 5;
    public void run(){
    while(true){
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    System.out.println("Thread " + threadNum + " = " + i);
    if(--i==0) return;
    }
    }
    public static void main(String[] args){
    for(int i=0; i<5; i++)

    new Thread(new TestThread()).start();//（1）

    }
    }
    執行結果為：

    Thread 1 = 5
    Thread 2 = 5
    Thread 3 = 5
    Thread 4 = 5
    Thread 5 = 5
    Thread 1 = 4
    Thread 2 = 4
    Thread 3 = 4
    Thread 4 = 4
    Thread 4 = 3
    Thread 5 = 4
    Thread 1 = 3
    Thread 2 = 3
    Thread 3 = 3
    Thread 4 = 2
    Thread 5 = 3
    Thread 1 = 2
    Thread 2 = 2
    Thread 3 = 2
    Thread 4 = 1
    Thread 5 = 2
    Thread 1 = 1
    Thread 2 = 1
    Thread 3 = 1
    Thread 5 = 1
    例3是對例2的修改，它通過實現Runnable介面來實現並行處理。程式碼（1）處可見，要呼叫TestThread中的並行操作部分，要把一個TestThread物件作為引數來產生Thread物件，再呼叫Thread物件的start()函式。

    3)    同一個實現了Runnable介面的物件作為引數產生的所有Thread物件是同一物件下的執行緒。

    例3.2：

    package mypackage1;
    public class TestThread implements Runnable{
    public synchronized void run(){
    for(int i=0; i<5; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    public static void main(String[] args){
    TestThread testThread = new TestThread();
    for(int i=0; i<5; i++)

    //new Thread(testThread, "t" + i).start();（1）

    new Thread(new TestThread(), "t" + i).start();（2）

    }
    }
    執行結果為：

    t0 : 0
    t1 : 0
    t2 : 0
    t3 : 0
    t4 : 0
    t0 : 1
    t1 : 1
    t2 : 1
    t3 : 1
    t4 : 1
    t0 : 2
    t1 : 2
    t2 : 2
    t3 : 2
    t4 : 2
    t0 : 3
    t1 : 3
    t2 : 3
    t3 : 3
    t4 : 3
    t0 : 4
    t1 : 4
    t2 : 4
    t3 : 4
    t4 : 4
    由於程式碼（2）每次都是用一個新的TestThread物件來產生Thread物件的，所以產生出來的Thread物件是不同物件的執行緒，所以所有Thread物件都可同時訪問run()函式。如果註釋掉程式碼（2），並去掉程式碼（1）的註釋，結果為：

    t0 : 0
    t0 : 1
    t0 : 2
    t0 : 3
    t0 : 4
    t1 : 0
    t1 : 1
    t1 : 2
    t1 : 3
    t1 : 4
    t2 : 0
    t2 : 1
    t2 : 2
    t2 : 3
    t2 : 4
    t3 : 0
    t3 : 1
    t3 : 2
    t3 : 3
    t3 : 4
    t4 : 0
    t4 : 1
    t4 : 2
    t4 : 3
    t4 : 4
    由於程式碼（1）中每次都是用同一個TestThread物件來產生Thread物件的，所以產生出來的Thread物件是同一個物件的執行緒，所以實現run()函式的同步。

    二．    共享資源的同步

    1.    同步的必要性

    例4：

    class Seq{
    private static int number = 0;
    private static Seq seq = new Seq();
    private Seq() {}
    public static Seq getInstance(){
    return seq;
    }
    public int get(){
    number++; //（a）

    return number;//（b）

    }
    }
    public class TestThread{
    public static void main(String[] args){
    Seq.getInstance().get();//（1）

    Seq.getInstance().get();//（2）

    }
    }
    上面是一個取得序列號的單例模式的例子，但呼叫get()時，可能會產生兩個相同的序列號：

    當代碼（1）和（2）都試圖呼叫get()取得一個唯一的序列。當代碼（1）執行完程式碼（a），正要執行程式碼（b）時，它被中斷了並開始執行程式碼（2）。一旦當代碼（2）執行完（a）而程式碼（1）還未執行程式碼（b），那麼程式碼（1）和程式碼（2）就將得到相同的值。

    2.    通過synchronized實現資源同步

    2.1    鎖標誌

    2.1.1    每個物件都有一個標誌鎖。當物件的一個執行緒訪問了物件的某個synchronized資料（包括函式）時，這個物件就將被“上鎖”，所以被宣告為synchronized的資料（包括函式）都不能被呼叫（因為當前執行緒取走了物件的“鎖標誌”）。只有當前執行緒訪問完它要訪問的synchronized資料，釋放“鎖標誌”後，同一個物件的其它執行緒才能訪問synchronized資料。

    2.1.2    每個class也有一個“鎖標誌”。對於synchronized static資料（包括函式）可以在整個class下進行鎖定，避免static資料的同時訪問。

    例5：

    class Seq{
    private static int number = 0;
    private static Seq seq = new Seq();
    private Seq() {}
    public static Seq getInstance(){
    return seq;
    }
    public synchronized int get(){ //（1）

    number++;
    return number;
    }
    }
    例5在例4的基礎上，把get()函式宣告為synchronized，那麼在同一個物件中，就只能有一個執行緒呼叫get()函式，所以每個執行緒取得的number值就是唯一的了。

    例6：

    class Seq{
    private static int number = 0;
    private static Seq seq = null;
    private Seq() {}
    synchronized public static Seq getInstance(){ //（1）

    if(seq==null)    seq = new Seq();
    return seq;
    }
    public synchronized int get(){
    number++;
    return number;
    }
    }
    例6把getInstance()函式宣告為synchronized，那樣就保證通過getInstance()得到的是同一個seq物件。

    2.2    non-static的synchronized資料只能在同一個物件的純種實現同步訪問，不同物件的執行緒仍可同時訪問。

    例7：

    class TestSynchronized implements Runnable{
    public synchronized void run(){//（1）

    for(int i=0; i<10; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    /*（2）*/
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    }
    public class TestThread{
    public static void main(String[] args){
    TestSynchronized r1 = new TestSynchronized();
    TestSynchronized r2 = new TestSynchronized();
    Thread t1 = new Thread(r1, "t1");
    Thread t2 = new Thread(r2, "t2");//(3)

    //Thread t2 = new Thread(r1, "t2");（4）

    t1.start();
    t2.start();
    }
    }
    執行結果為：

    t1 : 0
    t2 : 0
    t1 : 1
    t2 : 1
    t1 : 2
    t2 : 2
    t1 : 3
    t2 : 3
    t1 : 4
    t2 : 4
    t1 : 5
    t2 : 5
    t1 : 6
    t2 : 6
    t1 : 7
    t2 : 7
    t1 : 8
    t2 : 8
    t1 : 9
    t2 : 9
    雖然我們在程式碼（1）中把run()函式宣告為synchronized，但由於t1、t2是兩個物件（r1、r2）的執行緒，而run()函式是non-static的synchronized資料，所以仍可被同時訪問（程式碼（2）中的sleep()函式由於在暫停時不會釋放“標誌鎖”，因為執行緒中的迴圈很難被中斷去執行另一個執行緒，所以程式碼（2）只是為了顯示結果）。

    如果把例7中的程式碼（3）註釋掉，並去年程式碼（4）的註釋，執行結果將為：

    t1 : 0
    t1 : 1
    t1 : 2
    t1 : 3
    t1 : 4
    t1 : 5
    t1 : 6
    t1 : 7
    t1 : 8
    t1 : 9
    t2 : 0
    t2 : 1
    t2 : 2
    t2 : 3
    t2 : 4
    t2 : 5
    t2 : 6
    t2 : 7
    t2 : 8
    t2 : 9
    修改後的t1、t2是同一個物件（r1）的執行緒，所以只有當一個執行緒（t1或t2中的一個）執行run()函式，另一個執行緒才能執行。

    2.3    物件的“鎖標誌”和class的“鎖標誌”是相互獨立的。

    例8：

    class TestSynchronized extends Thread{
    public TestSynchronized(String name){
    super(name);
    }
    public synchronized static void prt(){
    for(int i=10; i<20; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    public synchronized void run(){
    for(int i=0; i<10; i++){
    System.out.println(Thread.currentThread().getName() + " : " + i);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    }
    public class TestThread{
    public static void main(String[] args){
    TestSynchronized t1 = new TestSynchronized("t1");
    TestSynchronized t2 = new TestSynchronized("t2");
    t1.start();
    t1.prt();//（1）

    t2.prt();//（2）

    }
    }
    執行結果為：

    main : 10
    t1 : 0
    main : 11
    t1 : 1
    main : 12
    t1 : 2
    main : 13
    t1 : 3
    main : 14
    t1 : 4
    main : 15
    t1 : 5
    main : 16
    t1 : 6
    main : 17
    t1 : 7
    main : 18
    t1 : 8
    main : 19
    t1 : 9
    main : 10
    main : 11
    main : 12
    main : 13
    main : 14
    main : 15
    main : 16
    main : 17
    main : 18
    main : 19
    在程式碼（1）中，雖然是通過物件t1來呼叫prt()函式的，但由於prt()是靜態的，所以呼叫它時不用經過任何物件，它所屬的執行緒為main執行緒。

    由於呼叫run()函式取走的是物件鎖，而呼叫prt()函式取走的是class鎖，所以同一個執行緒t1（由上面可知實際上是不同執行緒）呼叫run()函式且還沒完成run()函式時，它就能呼叫prt()函式。但prt()函式只能被一個執行緒呼叫，如程式碼（1）和程式碼（2），即使是兩個不同的物件也不能同時呼叫prt()。

    3.    同步的優化

    1)    synchronizedblock

    語法為：synchronized(reference){ do this }
    reference用來指定“以某個物件的鎖標誌”對“大括號內的程式碼”實施同步控制。

    例9：

    class TestSynchronized implements Runnable{
    static int j = 0;
    public synchronized void run(){
    for(int i=0; i<5; i++){
    //（1）

    System.out.println(Thread.currentThread().getName() + " : " + j++);
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    }
    public class TestThread{
    public static void main(String[] args){
    TestSynchronized r1 = new TestSynchronized();
    TestSynchronized r2 = new TestSynchronized();
    Thread t1 = new Thread(r1, "t1");
    Thread t2 = new Thread(r1, "t2");
    t1.start();
    t2.start();
    }
    }
    執行結果為：

    t1 : 0
    t1 : 1
    t1 : 2
    t1 : 3
    t1 : 4
    t2 : 5
    t2 : 6
    t2 : 7
    t2 : 8
    t2 : 9
    上面的程式碼的run()函式實現了同步，使每次打印出來的j總是不相同的。但實際上在整個run()函式中，我們只關心j的同步，而其餘程式碼同步與否我們是不關心的，所以可以對它進行以下修改：

    class TestSynchronized implements Runnable{
    static int j = 0;
    public void run(){
    for(int i=0; i<5; i++){
    //（1）

    synchronized(this){
    System.out.println(Thread.currentThread().getName() + " : " + j++);
    }
    try{
    Thread.sleep(100);
    }
    catch(InterruptedException e){
    System.out.println("Interrupted");
    }
    }
    }
    }
    public class TestThread{
    public static void main(String[] args){
    TestSynchronized r1 = new TestSynchronized();
    TestSynchronized r2 = new TestSynchronized();
    Thread t1 = new Thread(r1, "t1");
    Thread t2 = new Thread(r1, "t2");
    t1.start();
    t2.start();
    }
    }
    執行結果為：

    t1 : 0
    t2 : 1
    t1 : 2
    t2 : 3
    t1 : 4
    t2 : 5
    t1 : 6
    t2 : 7
    t1 : 8
    t2 : 9
    由於進行同步的範圍縮小了，所以程式的效率將提高。同時，程式碼（1）指出，當對大括號內的println()語句進行同步控制時，會取走當前物件的“鎖標誌”，即對當前物件“上鎖”，不讓當前物件下的其它執行緒執行當前物件的其它synchronized資料。

相關推薦

理解 JAVA多執行緒技術之詳解

1.    虛假的多執行緒     例1：     public class TestThread     {     int i=0, j=0;     public void go(int flag){     while(true){     try{    

Java多執行緒——synchronized使用詳解

一 前言 Java多執行緒是面試必考的知識點，哈哈，說的有點太絕對了，題外話不說那麼多了，今天我們就來了解一下Java多執行緒中的synchronized。 synchronized相信大家都看過或者用過，synchronized是Java中的關鍵字，synchronized可以

Java多執行緒---阻塞佇列詳解（舉例說明）

一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解決了多執行緒中，如何高效安全“傳輸”資料的問題。通過這些高效並且執行緒安全的佇列類，為我們快速搭建高質量的多執行緒程式帶來極大的便利。本文詳細介紹了BlockingQueue家庭中的所有成員

java多執行緒小示例詳解

package com.chillax.controller; import java.io.IOException; public class MultiThread { public static void main(String[] args) { System.out.p

JAVA多執行緒 join() 方法詳解及應用場景

在某些情況下，主執行緒建立並啟動了子執行緒，如果子執行緒中需要進行大量的耗時運算，主執行緒往往將早於子執行緒結束之前結束，如果主執行緒想等待子執行緒執行完畢後，獲得子執行緒中的處理完的某個資料，就要用

Java多執行緒-Thread.yield詳解

http://blog.csdn.net/dabing69221/article/details/17426953 Thread.yield( )方法： 使當前執行緒從執行狀態（執行狀態）變為可執行態（就緒狀態）。cpu會從眾多的可執行態裡選擇，也就是說，當前也就

java多執行緒-join方法詳解(附面試題)

本文對java Thread中join()方法進行介紹，join()的作用是讓“主執行緒”等待“子執行緒”結束之後才能繼續執行，大家參考使用吧 本章涉及到的內容包括： 1. join()

白話理解java多執行緒之join()方法

join字面意思是加入,我理解為插隊. 舉例:媽媽在炒菜,發現沒喲醬油了,讓兒子去打醬油,兒子打完醬油,媽媽炒完菜,全家一起吃 package cn.yh.thread01; /** * * 打醬油的例子 */ public class Demo03 { public stat

Java多執行緒學習之wait、notify/notifyAll 詳解

轉載 https://www.cnblogs.com/moongeek/p/7631447.html 1、wait()、notify/notifyAll() 方法是Object的本地final方法，無法被重寫。 2、wait()使當前執行緒阻塞，前提是 必須先獲

併發程式設計之美，帶你深入理解java多執行緒原理

1.什麼是多執行緒？ 多執行緒是為了使得多個執行緒並行的工作以完成多項任務，以提高系統的效率。執行緒是在同一時間需要完成多項任務的時候被實現的。 2.瞭解多執行緒 瞭解多執行緒之前我們先搞清楚幾個重要的概念！ 如上圖所示：對我們的專案有一個主記憶體，這個主記憶體裡面存放了我們的共享變數、方法區、堆中的物件等

詳解Java多執行緒鎖之synchronized

synchronized是Java中解決併發問題的一種最常用的方法，也是最簡單的一種方法。 synchronized的四種使用方式 修飾程式碼塊：被修飾的程式碼塊稱為同步語句塊，其作用的範圍是大括號{}括起來的程式碼，作用於呼叫物件 修飾方法：被修飾的方法稱為同步方法，其作用的範圍是整個方法，作用於呼叫物件

java架構之路（多執行緒）synchronized詳解以及鎖的膨脹升級過程

　　上幾次部落格，我們把volatile基本都說完了，剩下的還有我們的synchronized，還有我們的AQS，這次部落格我來說一下synchronized的使用和原理。 　　synchronized是jvm內部的一把隱式鎖，一切的加鎖和解鎖過程是由jvm虛擬機器來控制的，不需要我們認為的干預，我們大致從瞭

java多執行緒程式設計之使用Synchronized塊同步變數

通過synchronized塊來同步特定的靜態或非靜態方法。 要想實現這種需求必須為這些特性的方法定義一個類變數，然後將這些方法的程式碼用synchronized塊括起來，並將這個類變數作為引數傳入synchronized塊   下面的程式碼演示瞭如何同步特定的類方法：

【JAVA多執行緒問題之死鎖】

  一、死鎖是什麼？ 舉個例子：兩個人一起吃飯，每個人都拿了一隻筷子，雙方都在等待對方將筷子讓給自己，結果兩個人都吃不了飯。這種情況和計算機中的死鎖情況很相似。 假設有兩個執行緒，互相等待對方釋放佔有的鎖，但是釋放鎖的條件又不可能形成，這時候死鎖就形成了。 還是買票的問題，有的時候時會發生死

Java多執行緒-併發之執行緒池

執行緒池有了解嗎？ 答： java.util.concurrent.ThreadPoolExecutor 類就是一個執行緒池。客戶端呼叫ThreadPoolExecutor.submit(Runnable task) 提交任務，執行緒池內部維護的工作者執行緒的數量就是該執行緒池的執行

Java多執行緒-併發之synchronized 關鍵字

synchronized 關鍵字 答： 底層實現： 進入時，執行 monitorenter，將計數器 +1，釋放鎖 monitorexit 時，計數器 -1 當一個執行緒判斷到計數器為 0 時，則當前鎖空閒，可以佔用；反之，當前執行緒進入等待狀態 含義

Java多執行緒-併發之sleep() 和 wait(n) 、 wait() 的區別

sleep() 和 wait(n) 、 wait() 的區別 答： sleep 方法：是 Thread 類的靜態方法，當前執行緒將睡眠 n 毫秒，執行緒進入阻塞狀態。當睡眠時間到了，會接觸阻塞，進入可執行狀態，等待 CPU 的到來。睡眠不釋放鎖（如果有的話） wai

Java多執行緒-併發之多執行緒產生死鎖的4個必要條件？如何避免死鎖？

多執行緒產生死鎖的4個必要條件？ 答： 互斥條件：一個資源每次只能被一個執行緒使用 請求與保持條件：一個執行緒因請求資源而阻塞時，對已獲得的資源保持不放 不剝奪條件：程序已經獲得的資源，在未使用完之前，不能強行剝奪 迴圈等待條件：若干執行緒之間形成一種頭

Java多執行緒-併發之執行緒和程序的區別

執行緒和程序的區別 答： 程序是一個“執行中的程式”，是系統進行資源分配和排程的一個獨立單位 執行緒是程序的一個實體，一個程序中擁有多個執行緒，執行緒之間共享地址空間和其他資源（所以通訊和同步等操作執行緒比程序更加容易） 執行緒上下文的切換比程序上下文切換要快

Java多執行緒-併發之如何制定多個執行緒的執行順序？

文章目錄 如何讓10個執行緒按照順序列印0123456789？ 程式碼如下： 1.建立一個鎖物件類 2.建立一個執行緒類 3.測試類 如何讓10個執行緒按照順序列印012