day20_多執行緒入門丶執行緒安全

package Demo0;

/*
 方式一：同步程式碼塊
 *
 *   synchronized(同步監視器){
 *      //需要被同步的程式碼
 *
 *   }
 *  說明：1.操作共享資料的程式碼，即為需要被同步的程式碼。  -->不能包含程式碼多了，也不能包含程式碼少了。
 *       2.共享資料：多個執行緒共同操作的變數。比如：ticket就是共享資料。
 *       3.同步監視器，俗稱：鎖。任何一個類的物件，都可以充當鎖。
 *          要求：多個執行緒必須要共用同一把鎖。

 *  5.同步的方式，解決了執行緒的安全問題。---好處
 *    操作同步程式碼時，只能有一個執行緒參與，其他執行緒等待。相當於是一個單執行緒的過程，效率低。 ---侷限性
 */
public class TicketDemo implements Runnable {
    private int ticket = 100;
    Object object = new Object();

    /**
     * 執行賣票操作
     */
    @Override
    public void run() {
        //每個視窗賣票的操作
        // 視窗 永遠開啟
        while (true) {
            synchronized (object) {
                if (ticket > 0) {        //有票 可以賣
                    // 出票操作
                    // 使用sleep模擬一下出票時間
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //獲取當前執行緒物件的名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在賣:" + ticket--);
                }
            }
        }
    }
}

class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {

            show();
        }
    }

    private synchronized void show(){//同步監視器：this
            if (ticket > 0) {

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

                System.out.println(Thread.currentThread().getName() + ":賣票，票號為：" + ticket);

                ticket--;
            }
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

        t1.start();
        t2.start();
        t3.start();
    }

}

使用同步方法處理繼承Thread類的方式中的執行緒安全問題

class Window4 extends Thread {


    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步監視器：Window4.class
        //private synchronized void show(){ //同步監視器：t1,t2,t3。此種解決方式是錯誤的
        if (ticket > 0) {

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

            System.out.println(Thread.currentThread().getName() + "：賣票，票號為：" + ticket);
            ticket--;
        }
    }
}


public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

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

    }
}

同步機制中的鎖

• 在《Thinking in Java》中，是這麼說的：對於併發工作，你需要某種方式來防 止兩個任務訪問相同的資源（其實就是共享資源競爭）。 防止這種衝突的方法 就是當資源被一個任務使用時，在其上加鎖。第一個訪問某項資源的任務必須 鎖定這項資源，使其他任務在其被解鎖之前，就無法訪問它了，而在其被解鎖 之時，另一個任務就可以鎖定並使用它了。

synchronized的鎖是什麼？

任意物件都可以作為同步鎖。所有物件都自動含有單一的鎖（監視器）。

• 同步方法的鎖：靜態方法（類名.class）、非靜態方法（this）
• 同步程式碼塊：自己指定，很多時候也是指定為this或類名.class

注意：

• 必須確保使用同一個資源的多個執行緒共用一把鎖，這個非常重要，否則就 無法保證共享資源的安全
• 一個執行緒類中的所有靜態方法共用同一把鎖（類名.class），所有非靜態方 法共用同一把鎖（this），同步程式碼塊（指定需謹慎）

如何找問題，即程式碼是否存線上程安全？（非常重要）

• 明確哪些程式碼是多執行緒執行的程式碼
• 明確多個執行緒是否有共享資料
• 明確多執行緒執行程式碼中是否有多條語句操作共享資料

如何解決呢？（非常重要）

• 對多條操作共享資料的語句，只能讓一個執行緒都執行完，在執行過程中，其 他執行緒不可以參與執行。 即所有操作共享資料的這些語句都要放在同步範圍中
• 範圍太小：沒鎖住所有有安全問題的程式碼
• 範圍太大：沒發揮多執行緒的功能。

釋放鎖的操作

• 當前執行緒的同步方法、同步程式碼塊執行結束。
• 當前執行緒在同步程式碼塊、同步方法中遇到break、return終止了該程式碼塊、 該方法的繼續執行。
• 當前執行緒在同步程式碼塊、同步方法中出現了未處理的Error或Exception，導 致異常結束。
• 當前執行緒在同步程式碼塊、同步方法中執行了執行緒物件的wait()方法，當前線 程暫停，並釋放鎖。

class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){

        if(instance == null){

            synchronized (Bank.class) {
                if(instance == null){

                    instance = new Bank();
                }

            }
        }
        return instance;
    }

}

/**
 * 演示執行緒的死鎖問題
 *
 * 1.死鎖的理解：不同的執行緒分別佔用對方需要的同步資源不放棄，
 * 都在等待對方放棄自己需要的同步資源，就形成了執行緒的死鎖
 *
 * 2.說明：
 * 1）出現死鎖後，不會出現異常，不會出現提示，只是所有的執行緒都處於阻塞狀態，無法繼續
 * 2）我們使用同步時，要避免出現死鎖。
 *
 */
public class ThreadTest {

    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();


        new Thread(){
            @Override
            public void run() {

                synchronized (s1){

                    s1.append("a");
                    s2.append("1");

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


                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }


                }

            }
        }.start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){

                    s1.append("c");
                    s2.append("3");

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

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }


                }



            }
        }).start();


    }


}

package com.atguigu.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解決執行緒安全問題的方式三：Lock鎖  --- JDK5.0新增
 *
 * 1. 面試題：synchronized 與 Lock的異同？
 *   相同：二者都可以解決執行緒安全問題
 *   不同：synchronized機制在執行完相應的同步程式碼以後，自動的釋放同步監視器
 *        Lock需要手動的啟動同步（lock()），同時結束同步也需要手動的實現（unlock()）
 
 */
class Window implements Runnable{

    private int ticket = 100;
    //1.例項化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.呼叫鎖定方法lock()
                lock.lock();

                if(ticket > 0){

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

                    System.out.println(Thread.currentThread().getName() + "：售票，票號為：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.呼叫解鎖方法：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("視窗1");
        t2.setName("視窗2");
        t3.setName("視窗3");

        t1.start();
        t2.start();
        t3.start();
    }
}