Java多執行緒(傳智播客視訊)

(一)傳統執行緒技術回顧

1.建立執行緒的兩種方式

(1)建立Thread的子類，重寫run方法

(2)給Thread類傳入Runnable介面

(3)兩種建立方式的比較

第一點：通過建立執行緒方式可以看出，一個是繼承一個是實現介面，由於Java是隻能繼承一個父類，可以實現多個介面，所以說採用Runnable方式可以避免Thread方式由於Java單繼承帶來的缺陷

第二點：Runnable的程式碼可以被多個執行緒共享(Thread例項)，適合於多個執行緒處理同一資源的情況

第三點：Runnable更傾向於面向物件的程式設計思想，new Thread()表示執行緒，傳入Runnable介面代表任務物件

2.Thread原始碼

public class Thread implements Runnable {
  private Runnable target;

  //方法一：無參構造
  public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
  }
  //方法二：引數為Runnable型別
  public Thread(Runnable target) {
        //呼叫方法三
        init(null, target, "Thread-" + nextThreadNum(), 0 
);
  }
  //方法三
  private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        //呼叫方法四
        init(g, target, name, stackSize, null, true);
  }
  //方法四
  private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean 
 inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {

            if (security != null) {
                g = security.getThreadGroup();
            }

            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        g.checkAccess();

        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();

        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        //給Runnable型別的引數賦值
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

        this.stackSize = stackSize;

        tid = nextThreadID();
    } 
    //方法五：開啟執行緒的方法
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;
        try {
            //呼叫了方法六 native方法
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    //方法六 native方法
    private native void start0();

    @Override
    public void run() {
        //判斷Runnable型別的成員變數是否為空
        if (target != null) {
            target.run();
        }
    }
}

3.Runnable原始碼

//函式式介面
@FunctionalInterface
public interface Runnable {

    public abstract void run();

}

4.建立執行緒的案例

public class TraditionalThread {

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 1:Thread-0
                    System.out.println("1:" + Thread.currentThread().getName());
                    // 2:Thread-0  this這裡代表的是Thread物件
                    System.out.println("2:" + this.getName());
                }
            }
        };
        thread.start();

        Thread thread2 = new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // Thread-1
                    System.out.println(Thread.currentThread().getName());
                }
            }
        });
        thread2.start();

        // thread:Thread-2  
        // Thread的子類中run方法 Runnable中的run方法 優先呼叫子類的run方法
        new Thread(new Runnable() {

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

}

5.多執行緒機制會提高程式的執行效率嗎？為什麼會有多執行緒下載呢？

不會多執行緒下載：搶佔了伺服器的頻寬假設每個人的下載速度為20k，一個執行緒代表一個人，啟動多個執行緒代表10個人在下載，就給提供了200k的下載速度

（二）傳統定時器技術回顧

1.定時器的應用 Timer類和TimerTask類

(1)案例一：10秒後啟動,每隔3秒啟動一個

public class TraditionalTimerTest {
    public static void main(String[] args) {
        new Timer().schedule(new TimerTask() {

            @Override
            public void run() {
                System.out.println("boming!");
                // Timer-0
                System.out.println(Thread.currentThread().getName());
            }
        }, 10000, 3000);// 10秒後啟動,每隔3秒啟動一個
        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);// 單位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(2)案例二：每隔兩秒鐘啟動一次(也可以採用案例一的方法)

注意：每個TimerTask()只能執行一次

public class TraditionalTimerTest2 {
    public static void main(String[] args) {
        class MyTimerTask extends TimerTask {

            @Override
            public void run() {
                System.out.println("boming!");
                new Timer().schedule(new MyTimerTask(), 2000);
            }

        }
        new Timer().schedule(new MyTimerTask(), 2000);
        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(3)案例三：先隔兩秒啟動，再隔4秒啟動，如此迴圈

public class TraditionalTimerTest3 {
    // 內部類中不能宣告靜態變數 所以寫在外面
    private static int count = 0;

    public static void main(String[] args) {

        class MyTimerTask extends TimerTask {
            @Override
            public void run() {
                count = (count + 1) % 2;
                System.out.println("boming!");
                new Timer().schedule(new MyTimerTask(), 2000 + 2000 * count);
            }

        }
        new Timer().schedule(new MyTimerTask(), 2000);
        while (true) {
            System.out.println(new Date().getSeconds());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

(三)傳統執行緒互斥技術

1.執行緒安全問題

多個執行緒操作相同一份資料的時候就會出現執行緒安全的問題(銀行轉賬為例)

在靜態方法中，不能new內部類的例項物件

原因：內部類，可以訪問外部類的成員變數，呼叫靜態方法的時候，沒有建立物件，此時沒有可以訪問的成員變數，所以會報錯

案例:

public class TraditionalThreadSynchronized {

    public static void main(String[] args) {
        new TraditionalThreadSynchronized().init();
    }

    private void init() {
        Outputer outputer = new Outputer();
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("zhangsan");
                }
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("lisi");
                }
            }
        }).start();
    }

    class Outputer {
        public void output(String name) {
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}

列印結果：

zhanglisis
an
zhangsan
lisi
lzihangsan
si
zhangsan
lisi
zhlisi
angsan
lisi
zhangsan
lisi
zhangsan
lzhangsanisi
...

2.使用synchronized程式碼塊解決

互斥一定要是同一個物件

class Outputer {
        public void output(String name) {
            int len = name.length();
            synchronized (Outputer.class) {
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
        }
}

3.使用synchronized方法

class Outputer {
        public synchronized void output(String name) {
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
}

static synchronized方法鎖的是位元組碼物件
互斥用的是synchronized，synchronized是檢查一把鎖物件，多個執行緒要在一段程式碼上實現同步，必須是使用同一把鎖去擋住執行緒

（四）傳統執行緒同步通訊技術

1.面試題：子執行緒迴圈10次，接著主執行緒迴圈100次，接著又回到子執行緒迴圈10次，接著再回到主執行緒又迴圈100次，如此迴圈50次，請寫出程式

要用到共同資料(包括同步鎖)或共同演算法的若干個方法應該歸在同一個類身上，這種設計正好體現了高內聚和程式的健壯性
鎖是上在代表要操作的資源的類的內部方法中，而不是執行緒程式碼中

public class TraditionalThreadCommunication {

    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }
            }
        }).start();
        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }
    }

}

class Business {
    private boolean bShouldSub = true;

    public synchronized void sub(int i) {
        if (!bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int j = 1; j <= 10; j++) {
            System.out.println("sub thread sequece of" + j + ",loop of" + i);
        }
        bShouldSub = false;
        this.notify();
    }

    public synchronized void main(int i) {
        if (bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 100; j++) {
            System.out.println("main thread sequece of" + j + ",loop of" + i);
        }
        bShouldSub = true;
        this.notify();
    }
}

這種情況下使用while使得程式更加健壯

class Business {
    private boolean bShouldSub = true;

    public synchronized void sub(int i) {
        while (!bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        for (int j = 1; j <= 10; j++) {
            System.out.println("sub thread sequece of" + j + ",loop of" + i);
        }
        bShouldSub = false;
        this.notify();
    }

    public synchronized void main(int i) {
        while (bShouldSub) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int j = 1; j <= 100; j++) {
            System.out.println("main thread sequece of" + j + ",loop of" + i);
        }
        bShouldSub = true;
        this.notify();
    }
}

(五)執行緒範圍內共享變數的概念與作用

1.執行緒內部共享資料，執行緒間資料獨立

2.執行緒內部共享資料，執行緒間資料獨立的案例

public class ThreadScopeShareData {
    private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName() + "has put data :" + data);
                    threadData.put(Thread.currentThread(), data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            int data = threadData.get(Thread.currentThread());
            System.out.println("A from" + Thread.currentThread().getName() + "has put data :" + data);
        }
    }

    static class B {
        public void get() {
            int data = threadData.get(Thread.currentThread());
            System.out.println("B from" + Thread.currentThread().getName() + "has put data :" + data);
        }
    }

}

(六)ThreadLocal類及應用技巧

1.ThreadLocal

(1)ThreadLocal的作用和目的

用於實現執行緒內的資料共享，即對於相同的程式程式碼，多個模組在同一個執行緒中執行時要共享一份資料，而在另外執行緒中執行又共享另外一份資料

每個執行緒呼叫全域性ThreadLocal物件的set方法，就相當於往其內部的map中增加一條記錄，key分別是各自的執行緒，value是各自的set方法傳進去的值。線上程結束時可以呼叫ThreadLocal.clear()方法，這樣會更快釋放記憶體，不呼叫也可以，因為執行緒結束後也可以自動釋放相關的ThreadLocal變數

2.使用ThreadLocal改進上述案例

public class ThreadLocalTest {
    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName() + "has put data :" + data);
                    x.set(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println("A from" + Thread.currentThread().getName() + "has put data :" + data);
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println("B from" + Thread.currentThread().getName() + "has put data :" + data);
        }
    }
}

3.設計執行緒內範圍內共享的物件案例

public class ThreadLocalTest {
    private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    int data = new Random().nextInt();
                    System.out.println(Thread.currentThread().getName() + "has put data :" + data);
                    x.set(data);
                    MyThreadScopeData.getThreadInstance().setName("name" + data);
                    MyThreadScopeData.getThreadInstance().setAge(data);
                    new A().get();
                    new B().get();
                }
            }).start();
        }
    }

    static class A {
        public void get() {
            int data = x.get();
            System.out.println("A from" + Thread.currentThread().getName() + " has get data :" + data);
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("A from" + Thread.currentThread().getName() + " getMyData :" + myData.toString());
        }
    }

    static class B {
        public void get() {
            int data = x.get();
            System.out.println("B from" + Thread.currentThread().getName() + " has get data :" + data);
            MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
            System.out.println("B from" + Thread.currentThread().getName() + " getMyData :" + myData.toString());
        }
    }
}

class MyThreadScopeData {
    private MyThreadScopeData() {

    }

    // 在這個執行緒範圍內的任意地方呼叫都是一個物件,另一個執行緒呼叫則是另一個物件
    public static MyThreadScopeData getThreadInstance() {
        MyThreadScopeData instance = map.get();
        if (instance == null) {
            instance = new MyThreadScopeData();
            map.set(instance);
        }
        return instance;
    }

    private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "MyThreadScopeData [name=" + name + ", age=" + age + "]";
    }

}

Struts2的設計思想：每一個執行緒(請求)對應一個Action例項

(七)多個執行緒之間共享資料的方式探討

1.如果每個執行緒執行的程式碼相同，可以使用同一個Runnable物件，這個Runnable物件中有那個共享資料

2.如果每個執行緒執行的程式碼不同，這時候需要用不同的Runnable物件，有如下兩種方式來實現這些Runnable物件之間的資料共享

(1)將共享資料封裝在另外一個物件中，然後將這個物件逐一傳遞給各個Runnable物件。每個執行緒對共享資料的操作方法也分配到那個物件身上去完成，這樣容易實現針對該資料進行的各個操作的互斥和通訊

案例：

public class MultiThreadShareData {
    public static void main(String[] args) {

        MultiThreadShareData multiThreadShareData = new MultiThreadShareData();

        ShareData shareData = multiThreadShareData.new ShareData();

        MyRunnable1 runNable1 = multiThreadShareData.new MyRunnable1(shareData);
        MyRunnable2 runNable2 = multiThreadShareData.new MyRunnable2(shareData);
        new Thread(runNable1).start();
        new Thread(runNable2).start();
    }

    class ShareData {
        private int j = 0;

        public ShareData() {
        }

        public void increment() {
            j++;
        }

        public void decrement() {
            j--;
        }
    }

    class MyRunnable1 implements Runnable {
        private ShareData shareData;

        public MyRunnable1(ShareData shareData) {
            this.shareData = shareData;
        }

        public void run() {
            this.shareData.increment();
        }
    }

    class MyRunnable2 implements Runnable {
        private ShareData shareData;

        public MyRunnable2(ShareData shareData) {
            this.shareData = shareData;
        }

        public void run() {
            this.shareData.decrement();
        }
    }

}

(2)將這些Runnable物件作為某一個類中的內部類，共享資料作為這個外部類中的成員變數，每個執行緒對共享資料的操作方法也分配給外部類，以便實現對共享資料進行的各個操作的互斥和通訊，作為內部類的各個Runnable物件呼叫外部類的這些方法

案例：

public class MultiThreadShareData2 {
    public static void main(String[] args) {
        final ShareData shareData = new ShareData();

        new Thread(new Runnable() {
            public void run() {
                shareData.increment();
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                shareData.decrement();
            }
        }).start();
    }

}

class ShareData {
    private int j = 0;

    public ShareData() {
    }

    public void increment() {
        j++;
    }

    public void decrement() {
        j--;
    }
}

上面兩種方式的組合：將共享資料封裝在另外一個物件中，每個執行緒對共享資料的操作方法也分配到那個物件身上去完成，物件作為這個外部類中的成員變數或方法中的區域性變數，每個執行緒Runnable物件作為外部類中的成員變數或區域性內部類

總之，要同步互斥的幾段程式碼最好是分別放在幾個獨立的方法中，這些方法再放在同一個類中，這樣比較容易實現它們之間的同步互斥和通訊

極端且簡單的方式，即在任意一個類中定義一個static的變數，這將被所有執行緒共享

(八)Java5原子性操作類的應用

1.Package java.util.concurrent.atomic

一個小型工具包，支援單個變數上的無鎖執行緒安全程式設計,可以對基本資料，對陣列中的基本資料，對類中的基本資料等進行操作

這裡寫圖片描述

(九)Java5執行緒併發庫的應用

1.執行緒池的概念與Executors類的應用

(1)建立執行緒池的四種方式

Executors類的方法

newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒 newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待 newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行 newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行(如何實現執行緒死掉後重新啟動？)

(2)關閉執行緒池

ExecutorService介面的方法