執行緒的同步

• 在一般情況下，建立一個執行緒是不能提高程式的執行效率的，所以要建立多個執行緒。但是多個執行緒同時執行的時候可能呼叫執行緒函式，在多個執行緒同時對同一個記憶體地址進行寫入，由於CPU時間排程上的問題，寫入資料會被多次的覆蓋，所以就要使執行緒同步。

• 執行緒同步：即當有一個執行緒在對記憶體進行操作時，其他執行緒都不可以對這個記憶體地址進行操作，直到該執行緒完成操作， 其他執行緒才能對該記憶體地址進行操作，而其他執行緒又處於等待狀態，目前實現執行緒同步的方法有很多，臨界區物件就是其中一種。

摘自百度百科

同步的三種常用方法

1、同步程式碼塊

• 有synchronized關鍵字修飾的語句塊

程式碼如：

    synchronized(object){ 
    }

被該關鍵字修飾的語句塊會自動被加上內建鎖，從而實現同步

例項：

/**
 * 執行緒的同步
 * @author LingDu
 */
public class Demo1 extends Thread {

    //定義一個可共享的count
    private static int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try
 
 {
                Thread.sleep(1000);
                test1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 預設建構函式
    public Demo1() {
        super();
    }

    // 帶引數的建構函式
    public Demo1(String name) {
        super(name);
    }

    /**
     * 使用同步程式碼塊
     */
 

    public void test1() {
        synchronized (Demo1.class) {
            System.out.println(Thread.currentThread().getName() + "--->" + count);
            count = count + 1;
        }
    }



    public static void main(String[] args) {
        Demo1 demo1 = new Demo1("執行緒1");
        Demo1 demo2 = new Demo1("執行緒2");
        Demo1 demo3 = new Demo1("執行緒3");
        Demo1 demo4 = new Demo1("執行緒4");

        demo1.start();
        demo2.start();
        demo3.start();
        demo4.start();
    }

}

2、同步方法

• 有synchronized關鍵字修飾的方法

程式碼如：

public synchronized void save(){}

由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時，內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。

/**
 * 執行緒的同步
 * @author LingDu
 */
public class Demo1 extends Thread {

    //定義一個可共享的count
    private static int count = 0;

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
                test2();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 預設建構函式
    public Demo1() {
        super();
    }

    // 帶引數的建構函式
    public Demo1(String name) {
        super(name);
    }


    /**
     * 使用同步方法
     */
    public synchronized static void test2() {
        System.out.println(Thread.currentThread().getName() + "--->" + count);
        count = count + 1;
    }

    public static void main(String[] args) {
        Demo1 demo1 = new Demo1("執行緒1");
        Demo1 demo2 = new Demo1("執行緒2");
        Demo1 demo3 = new Demo1("執行緒3");
        Demo1 demo4 = new Demo1("執行緒4");

        demo1.start();
        demo2.start();
        demo3.start();
        demo4.start();
    }
}

3、使用特殊域變數(volatile)實現執行緒同步

• 用volatile修飾的變數，執行緒在每次使用變數的時候，都會讀取變數修改後的最的值。

public class Demo2 extends Thread {

    //定義一個狀態，用來控制執行緒
    private volatile boolean sign = true;

    public boolean isSign() {
        return sign;
    }

    public void setSign(boolean sign) {
        this.sign = sign;
    }

    public Demo2() {
        super();
    }

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

    @Override
    public void run() {
        // 迴圈10000次 ，模擬一個非常耗時的工作
        for (int i = 0; i < 10000; i++) {
            try {
                Thread.sleep(1000);
                if (sign == true) {
                    System.out.println(Thread.currentThread().getName() + "," + i);
                } else {
                    System.out.println(this.getName() + "我的狀態變了，我要退出了");
                    Thread.sleep(10000);
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        // 一個名字叫main的執行緒
        Demo2 d1 = new Demo2();
        Demo2 d2 = new Demo2();
        d1.start();
        d2.start();
        // 讓兩個執行緒都去執行5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //d1執行緒退出
        d1.setSign(false);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //d2執行緒退出
        d2.setSign(false);

    }

}

Timer類

構造方法

• Timer() 建立一個新計時器。

• Timer(boolean isDaemon) 建立一個新計時器，可以指定其相關的執行緒作為守護程式執行。

• Timer(String name) 建立一個新計時器，其相關的執行緒具有指定的名稱。

• Timer(String name, boolean isDaemon) 建立一個新計時器，其相關的執行緒具有指定的名稱，並且可以指定作為守護程式執行。

常用的方法：

• Void schedule(TimerTask task, long delay, long period) 安排指定的任務從指定的延遲後開始進行重複的固定延遲執行。

1、 內部類的方式實現

/**
     * 建立一個定時任務
     * 內部類方式實現
     * 建立一個類TimeTaskDemo繼承TimerTask，重寫run方法
     */
    public static void test1(){
        //內部類方式實現
        class TimeTaskDemo extends TimerTask{

            @Override
            public void run() {
                System.out.println("1");

            }
        }
        Timer timer = new Timer();
        //schedule(TimerTask task, long delay, long period)
        // 這裡的0表示立即執行 ， 1000表示每1秒執行一次
        timer.schedule(new TimeTaskDemo(), 0,1000);
    }

2、 匿名內部類實現

/**
     * 匿名內部類實現
     */
    public static void test2(){

        Timer timer = new Timer();
        //new一個TimerTask()重寫
        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("2");

            }
        }, 0,1000);
    }