2. 程式人生 > >Java併發程式設計原理與實戰一（執行緒狀態及建立執行緒的多種方式）

Java併發程式設計原理與實戰一（執行緒狀態及建立執行緒的多種方式）

阿新 • • 發佈：2018-12-25

一、為什麼要學習併發程式設計

1.發揮多處理的強大能力
2.建模的簡單性
3.非同步事件的簡化處理
4.響應更加靈敏的使用者介面

二、併發的缺點

1.安全性問題

多執行緒環境下
多個執行緒共享一個資源
對資源進行非原子性操作

2.活躍性問題（飢餓）

1、死鎖
2、飢餓
飢餓與公平
1）高優先順序吞噬所有低優先順序的CPU時間片
2）執行緒被永久堵塞在一個等待進入同步塊的狀態
3）等待的執行緒永遠不被喚醒
如何儘量避免飢餓問題
- 設定合理的優先順序
- 使用鎖來代替synchronized

3、活鎖

3.效能問題

三、執行緒的狀態

執行緒在一定條件下，狀態會發生變化。執行緒一共有以下幾種狀態：

1、新建狀態(New)：新建立了一個執行緒物件。

2、就緒狀態(Runnable)：執行緒物件建立後，其他執行緒呼叫了該物件的start()方法。該狀態的執行緒位於“可執行執行緒池”中，變得可執行，只等待獲取CPU的使用權。即在就緒狀態的程序除CPU之外，其它的執行所需資源都已全部獲得。

3、執行狀態(Running)：就緒狀態的執行緒獲取了CPU，執行程式程式碼。

4、阻塞狀態(Blocked)：阻塞狀態是執行緒因為某種原因放棄CPU使用權，暫時停止執行。直到執行緒進入就緒狀態，才有機會轉到執行狀態。

阻塞的情況分三種：

(1)、等待阻塞：執行的執行緒執行wait()方法，該執行緒會釋放佔用的所有資源，JVM會把該執行緒放入“等待池”中。進入這個狀態後，是不能自動喚醒的，必須依靠其他執行緒呼叫notify()或notifyAll()方法才能被喚醒，

(2)、同步阻塞：執行的執行緒在獲取物件的同步鎖時，若該同步鎖被別的執行緒佔用，則JVM會把該執行緒放入“鎖池”中。

(3)、其他阻塞：執行的執行緒執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該執行緒置為阻塞狀態。當sleep()狀態超時、join()等待執行緒終止或者超時、或者I/O處理完畢時，執行緒重新轉入就緒狀態。

5、死亡狀態(Dead)：執行緒執行完了或者因異常退出了run()方法，該執行緒結束生命週期。
執行緒變化的狀態轉換圖如下：
這裡寫圖片描述

四、建立執行緒的多種方式

1、繼承Thread類

public class Demo1 extends Thread {

    public Demo1(String name) {
        super(name);
    }

    @Override
    public void run() {
        while(!interrupted()) {
            System.out.println(getName() + "執行緒執行了 .. ");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        Demo1 d1 = new Demo1("first-thread");
        Demo1 d2 = new Demo1("second-thread");


        d1.start();
        d2.start();

//      d1.stop();
        d1.interrupt();
    }

}

2、實現Runnable介面

public class Demo2 implements Runnable {

    @Override
    public void run() {
        while(true) {
            System.out.println("thread running ...");
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Demo2());
        thread.start();
    }

}

3、匿名內部類的方式

public class Demo3 {

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable");
            }
        }) {
            public void run() {
                System.out.println("sub");
            };
        }.start();


    }

}

4、帶返回值的執行緒


import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Demo4 implements Callable<Integer> {


    public static void main(String[] args) throws Exception {
        Demo4 d = new Demo4();

        FutureTask<Integer> task = new FutureTask<>(d);

        Thread t = new Thread(task);

        t.start();

        System.out.println("我先乾點別的。。。");

        Integer result = task.get();
        System.out.println("執行緒執行的結果為：" + result);
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("正在進行緊張的計算....");
        Thread.sleep(3000);
        return 1;
    }

}

5、定時器（quartz）


import java.util.Timer;
import java.util.TimerTask;

public class Demo5 {

    public static void main(String[] args) {

        Timer timer = new Timer();

        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                // 實現定時任務
                System.out.println("timertask is run");
            }
        }, 0, 1000);

    }

}

6、執行緒池的實現


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 執行緒池
 * @author Administrator
 *
 */
public class Demo6 {

    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 1000; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

        threadPool.shutdown();
    }

}

7、Lambda表示式實現


import java.util.Arrays;
import java.util.List;
/**
 * lambda平行計算
 * @author Administrator
 *
 */
public class Demo7 {

    public static void main(String[] args) {

        List<Integer> values = Arrays.asList(10,20,30,40);
        int res = new Demo7().add(values);
        System.out.println("計算的結果為：" + res);


    }



    public int add (List<Integer> values) {
        values.parallelStream().forEach(System.out :: println);
        return values.parallelStream().mapToInt( i -> i * 2).sum();
    }

}

8、Spring實現多執行緒

五、Synchronized原理與使用

1、內建鎖
2、互斥鎖

1、修飾普通方法
2、修飾靜態方法
3、修飾程式碼塊

public class Sequence {

    private int value;

    /**
     * synchronized 放在普通方法上，內建鎖就是當前類的例項
     * @return
     */
    public synchronized int getNext() {
        return value ++;
    }

    /**
     * 修飾靜態方法，內建鎖是當前的Class位元組碼物件
     * Sequence.class
     * @return
     */
    public static synchronized int getPrevious() {
//      return value --;
        return 0;
    }

    public int xx () {

        // monitorenter
        synchronized (Sequence.class) {

            if(value > 0) {
                return value;
            } else {
                return -1;
            }

        }
        // monitorexit

    }

    public static void main(String[] args) {

        Sequence s = new Sequence();
//      while(true) {
//          System.out.println(s.getNext());
//      }

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }

}

六、任何物件都可以作為鎖，那麼鎖資訊又存在物件的什麼地方呢？

存在物件頭中

物件頭中的資訊
Mark Word：執行緒id、Epoch、物件的分代年齡資訊、是否是偏向鎖、鎖標誌位
Class Metadata Address
Array Length

偏向鎖

每次獲取鎖和釋放鎖會浪費資源
很多情況下，競爭鎖不是由多個執行緒，而是由一個執行緒在使用。
只有一個執行緒在訪問同步程式碼塊的場景

重量級鎖

七、設定執行緒優先順序

public class Target implements Runnable {

    @Override
    public void run() {

        while(true) {
            System.out.println(Thread.currentThread().getName() + " ...");
//          Thread.sleep(1);
        }

    }

}
public class Demo {

    public static void main(String[] args) {


        Thread t1 =  new Thread(new Target());
        Thread t2 =  new Thread(new Target());


        t1.setPriority(1);
        t2.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();

    }

}

八、單例模式與執行緒安全性問題

餓漢式

沒有執行緒安全性問題

public class Singleton {

    // 私有化構造方法
    private Singleton () {}

    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }

}

懶漢式

雙重檢查加鎖解決執行緒安全性問題

public class Singleton2 {

    private Singleton2() {}
    //volatile 解決指令重排序導致的執行緒安全性問題、過多將導致cpu快取優化失效
    private static volatile Singleton2 instance;

    /**
     * 雙重檢查加鎖
     * 
     * @return
     */
    public static Singleton2 getInstance () {
        // 自旋   while(true)
        if(instance == null) {
            synchronized (Singleton2.class) {
                if(instance == null) {
                    instance = new Singleton2();  // 指令重排序

                    // 申請一塊記憶體空間   // 1
                    // 在這塊空間裡實例化物件  // 2
                    // instance的引用指向這塊空間地址   // 3
                }
            }
        }
        return instance;
    }

}

九、鎖重入

public class Demo {


    public synchronized void a () {
        System.out.println("a");
//      b();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b() {
        System.out.println("b");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        //同一個對物件將會阻塞
        Demo d1= new Demo();
        Demo d2= new Demo();

        new Thread(new Runnable() {

            @Override
            public void run() {
                d1.a();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                d2.b();
            }
        }).start();
    }

}

十、自旋鎖

import java.util.Random;

/**
 * 多個執行緒執行完畢之後，列印一句話，結束
 * @author worker
 *
 */
public class Demo2 {

    public static void main(String[] args) {

        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 執行緒執行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 執行緒執行完畢了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 執行緒執行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 執行緒執行完畢了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 執行緒執行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 執行緒執行完畢了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 執行緒執行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 執行緒執行完畢了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 執行緒執行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 執行緒執行完畢了...");
            }
        }).start();

        while(Thread.activeCount() != 1) {
            // 自旋
        }
        System.out.println("所有的執行緒執行完畢了...");
    }

}

十一、死鎖

public class Demo3 {

    private Object obj1 = new Object();
    private Object obj2 = new Object();


    public void a () {
        synchronized (obj1) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2) {
                System.out.println("a");
            }
        }
    }

    public void b () {
        synchronized (obj2) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1) {
                System.out.println("b");
            }
        }
    }

    public static void main(String[] args) {

        Demo3 d = new Demo3();

        new Thread(new Runnable() {

            @Override
            public void run() {
                d.a();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                d.b();
            }
        }).start();
    }

}

十二、輕量級鎖

Volatile

Volatile稱之為輕量級鎖，被volatile修飾的變數，線上程之間是可見的。
可見：一個執行緒修改了這個變數的值，在另外一個執行緒中能夠讀到這個修改後的值。
Synchronized除了執行緒之間互斥意外，還有一個非常大的作用，就是保證可見性

public class Demo2 {

    public volatile boolean run = false;

    public static void main(String[] args) {

        Demo2 d = new Demo2();

        new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 1;i<=10;i++) {
                    System.err.println("執行了第 " + i + " 次");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                d.run = true;
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(!d.run) {
                    // 不執行
                }
                System.err.println("執行緒2執行了...");
            }
        }).start();


    }

}

Lock指令

在多處理器的系統上
1、將當前處理器快取行的內容寫回到系統記憶體
2、這個寫回到記憶體的操作會使在其他CPU裡快取了該記憶體地址的資料失效
硬碟 – 記憶體 – CPU的快取
多個執行緒可以同時

十三、JDK提供的原子類原理及使用

1、原子更新基本型別、原子更新陣列、原子更新抽象型別、原子更新欄位

public class User {

    private String name;

    public volatile int old;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getOld() {
        return old;
    }

    public void setOld(int old) {
        this.old = old;
    }

}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;

public class Sequence {

    private AtomicInteger value  = new AtomicInteger(0);

    private int [] s = {2,1,4,6};

    AtomicIntegerArray a = new AtomicIntegerArray(s);


    AtomicReference<User> user = new AtomicReference<>();

    AtomicIntegerFieldUpdater<User> old =  AtomicIntegerFieldUpdater.newUpdater(User.class, "old");

    /**
     * @return
     */
    public  int getNext() {

        User user = new User();
        System.out.println(old.getAndIncrement(user));
        System.out.println(old.getAndIncrement(user));
        System.out.println(old.getAndIncrement(user));



        a.getAndIncrement(2);
        a.getAndAdd(2, 10);
        return value.getAndIncrement();
    }

    public static void main(String[] args) {

        Sequence s = new Sequence();

        new Thread(new Runnable() {

            @Override
            public void run() {
//              while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//              }
            }
        }).start();

    }

}

十四、Lock介面的認識與使用

Lock與Synchronized的區別：

Lock需要顯示地獲取和釋放鎖，繁瑣能讓程式碼更靈活
Synchronized不需要顯示地獲取和釋放鎖，簡單

Lock的優勢：

使用Lock可以方便的實現公平性

非阻塞的獲取鎖
能被中斷的獲取鎖
超時獲取鎖

自己實現一個Lock


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Sequence {

    private int value;
    Lock lock = new ReentrantLock();
    Lock l1 = new ReentrantLock();

    /**
     * @return
     */
    public  int getNext() {
        lock.lock();
        int a = value ++;
        lock.unlock();
        return a;
    }

    public static void main(String[] args) {

        Sequence s = new Sequence();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }

}

相關推薦

Java併發程式設計原理與實戰一（執行緒狀態及建立執行緒的多種方式）

一、為什麼要學習併發程式設計 1.發揮多處理的強大能力 2.建模的簡單性 3.非同步事件的簡化處理 4.響應更加靈敏的使用者介面 二、併發的缺點 1.安全性問題 多執行緒環境下 多個執行緒共享一個資源 對資源進行非原子性操作 2.活躍

最新Java併發程式設計原理與實戰分享

課程大綱第1節你真的瞭解併發嗎？   00:27:48分鐘   | 第2節理解多執行緒與併發的之間的聯絡與區別   00:11:59分鐘   | 第3節解析多執行緒與多程序的聯絡以及上下文切換所

Java併發程式設計原理與實戰

推薦視訊連結 java併發程式設計是一個優秀的開發者成長過程中繞不過去的挑戰。資料庫服務，Web服務，大資料處理框架，分散式服務等等，併發程式設計往往扮演著極其重要的角色。天下武功，唯快不破。要想提高效能，併發必不可少。 市面上大多數講解併發的視訊教程大多基於

Java併發程式設計的藝術——讀書筆記（一） 併發程式設計的挑戰

第一章 併發程式設計的挑戰 因為最近找工作，準備筆試/面試，開始嘗試閱讀這本書，我不常寫部落格，距上一次寫已經過去大概一年時間了，連CSDN密碼都忘了/衰，所以這次新開一個賬號重新開始，希望我能堅持下去。 第一章沒什麼內容，我認為其目的主要是給出足夠多的閱讀這本書的理

Java併發程式設計：volatile關鍵字解析（一.記憶體模型的相關概念）

大家都知道，計算機在執行程式時，每條指令都是在CPU中執行的，而執行指令過程中，勢必涉及到資料的讀取和寫入。由於程式執行過程中的臨時資料是存放在主存（實體記憶體）當中的，這時就存在一個問題，由於CPU執行速度很快，而從記憶體讀取資料和向記憶體寫入資料的過程跟CPU執行指令

Java併發程式設計之鎖機制之（ReentrantLock)重入鎖

最近在忙公司的專案，現在終於有時間來寫部落格啦~開心開心 前言 通過前面的文章，我們已經瞭解了AQS(AbstractQueuedSynchronizer)內部的實現與基本原理。現在我們來了解一下，Java中為我們提供的Lock機制下的鎖實現--ReentrantLock（重入鎖），閱讀該篇文章

Java併發程式設計：Synchronized底層優化（偏向鎖、輕量級鎖） Java併發程式設計：Synchronized底層優化（偏向鎖、輕量級鎖）

轉自：https://www.cnblogs.com/paddix/p/5405678.html Java併發程式設計：Synchronized底層優化（偏向鎖、輕量級鎖）   Java併發程式設計系列： J

Java併發程式設計入門與高併發面試

第6章 J.U.C之AQS講解 AQS是J.U.C的重要元件，也是面試的重要考點。這一章裡將重點講解AQS模型設計及相關同步元件的原理和使用，都非常實用，具體包括：CountDownLatch、Semaphore、CyclicBarrier、ReentrantLock與鎖、Condition等。這些元

16-Java併發程式設計：Timer和TimerTask（轉載）

Java併發程式設計：Timer和TimerTask（轉載） 　　下面內容轉載自： 　　其實就Timer來講就是一個排程器,而TimerTask呢只是一個實現了run方法的一個類,而具體的TimerTask需要由你自己來實現,例如這樣: Timer timer =

Java併發程式設計：Timer和TimerTask（轉載）

public Timer(boolean isDaemon) { this("Timer-" + serialNumber(), isDaemon); }  　　另外兩個構造方法負責傳入名稱和將timer啟動： public Timer(String name, boo

Java併發程式設計：Synchronized底層優化（偏向鎖、輕量級鎖）

Java併發程式設計系列： 一、重量級鎖 　　上篇文章中向大家介紹了Synchronized的用法及其實現的原理。現在我們應該知道，Synchronized是通過物件內部的一個叫做監視器鎖（monitor）來實現的。但是監視器鎖本質又是依賴於底層的作業系統的Mutex Lock來實現的。而

java併發程式設計應用易忘知識點（1）java中的鎖

Lock介面 Java se5之後，出現了Lock介面，提供了與Synchronized類似同步功能。與synchronized相比，他雖然少了隱式獲取釋放鎖的便捷性，卻擁有了鎖獲取與釋放的可操作性、可中斷的獲取鎖以及超時獲取鎖等多種synchronized不具備的同步特性

Java併發程式設計：volatile關鍵字解析（二.併發程式設計中的三個概念）

在併發程式設計中，我們通常會遇到以下三個問題：原子性問題，可見性問題，有序性問題。我們先看具體看一下這三個概念： 1.原子性 　　原子性：即一個操作或者多個操作 要麼全部執行並且執行的過程不會被任何因素打斷，要麼就都不執行。 　　一個很經典的例子就是銀行賬戶轉賬問題

java網路程式設計—NIO與Netty(一)

java BIO 流 流是一個連續的寫入\讀取 的資料流。將網路、硬碟、記憶體中的資料寫入程式中稱為InputStream,方向相反輸出則稱為OutputStream 顯然，流具有方向性！ InputStream 對於java IO包的

Java併發程式設計的藝術(十一)——執行緒池(2)

Executor兩級排程模型 在HotSpot虛擬機器中，Java中的執行緒將會被一一對映為作業系統的執行緒。 在Java虛擬機器層面，使用者將多個任務提交給Executor框架，Execu

Java併發程式設計：volatile關鍵字解析（轉載）

Java併發程式設計：volatile關鍵字解析 　　 volatile這個關鍵字可能很多朋友都聽說過，或許也都用過。在Java 5之前，它是一個備受爭議的關鍵字，因為在程式中使用它往往會導致出人意料的結果。在Java 5之後，volatile關鍵字才得以重獲生機。 　　volatile關鍵字雖然

Java web程式設計之基礎理論詳解（計算機網路基礎，HTTP請求的完成過程）

1.計算機網路基礎知識 首先我們需明確通訊系統互聯參考模型： OSI/RM模型與TCP/IP模型：                  OSI/RM模型是一種事實上被TCP/IP模型淘汰的模型，在當今世界上沒有大規模使用。當發生HTTP請求時，傳送方傳送的資料是由最頂

Java併發程式設計之CAS第三篇-CAS的缺點及解決辦法

Java併發程式設計之CAS第三篇-CAS的缺點 通過前兩篇的文章介紹，我們知道了CAS是什麼以及檢視原始碼瞭解CAS原理。那麼在多執行緒併發環境中，的缺點是什麼呢？這篇文章我們就來討論討論 本篇是《凱哥(凱哥Java:kagejava)併發程式設計學習》系列之《CAS系列》教程的第三篇：CAS的缺點有哪些？

（執行緒一）執行緒概念及建立執行緒

概念定義：執行緒是程序中的一個任務，也叫順序執行流，同時執行一個程序中的多個任務（也就是執行多個順序執行流）就是多執行緒     程式：是作業系統中實現功能的程式碼塊，也叫軟體     程序：正在執行中的程式     多程序：多個程式同

Java併發程式設計高階技術-高效能併發框架原始碼解析與實戰（資源同步）

第1章 課程介紹（Java併發程式設計進階課程） 什麼是Disruptor？它一個高效能的非同步處理框架，號稱“單執行緒每秒可處理600W個訂單”的神器，本課程目標：徹底精通一個如此優秀的開源框架，面試秒殺面試官。本章會帶領小夥伴們先了解課程大綱與重點，然後模擬千萬，億級資料進行壓力測試。讓大