java筆記五：多線程的使用

　　以前學習基礎的時候學習了一段時間的多線程，上課的時候老師也講過一遍，那時候感覺學的似懂非懂。因為到現在很長一段時間沒有用到多線程的知識，所以現在基本上忘了差不多了。但是下個星期要面試了，所以今天特意又研究了一下多線程，免得被問到多線程問題時什么都不記得了那就麻煩了。現在對java比較熟悉了，所以再一次學習多線程知識，感覺沒有那么難了（記得剛接觸多線程的時候，感覺非常吃力）。

　　首先講一下進程和線程的區別：

　　　　進程：每個進程都有獨立的代碼和數據空間（進程上下文），進程間的切換會有較大的開銷，一個進程包含1--n個線程。

　　　　線程：同一類線程共享代碼和數據空間，每個線程有獨立的運行棧和程序計數器(PC)，線程切換開銷小。

　　　　線程和進程一樣分為五個階段：創建、就緒、運行、阻塞、終止。

　　　　多進程是指操作系統能同時運行多個任務（程序）。

　　　　多線程是指在同一程序中有多個順序流在執行。

　　在java中創建一個線程有兩種方法：

　　　　①實現java.lang.Runnable接口，重寫run()方法，啟動：new Thread(this).start()。

package com.thread;

public class ThreadTest1 {
    public static void main(String[] args) {
        Runnable1 r = new Runnable1();
        //r.run();並不是線程開啟，而是簡單的方法調用
        Thread t = new Thread(r);//創建線程
        //t.run(); //如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作並返回。
        t.start(); //線程開啟
        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);
        }
    }
}
class Runnable1 implements Runnable{
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-----:"+i);
        }
    }
}

　　要注意的是：

　　　　1.r.run()並不是啟動線程，而是簡單的方法調用。

　　　　2.Thread也有run()方法，如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作並返回。

　　　　3.並不是一啟動線程（調用start()方法）就執行這個線程，而是進入就緒狀態，什么時候運行要看CUP。

　　　　②繼承java.lang.Thread類，重寫run()方法。

package com.thread;

public class TestThread2 {
    public static void main(String[] args) {
        Thread1 t = new Thread1();
        //t.run(); //這里也不能直接調用方法
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);
        }
    }
}

//盡量使用實現Runnnable接口，因為接口比較靈活
class Thread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread-----:"+i);
        }
    }
}

雖然兩種方法都可行，但是最好還是用第一種方法，因為使用接口靈活性好，java中時單繼承、多實現。

Thread類中常用的方法有：

　　①sleep(long millis): 在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）。

package com.thread;
import java.util.Date;
/**
 * sleep()指在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）。
 * @author Administrator
 *
 */
public class SleepTest {
    public static void main(String[] args) {
        Thread2 t = new Thread2();
        t.start();
        try {
            Thread.sleep(10000); //主線程睡眠10秒鍾
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主線程睡眠10秒鍾后結束t線程
        //t.interrupt(); //這種結束方式比較粗暴，如果t線程打開了某個資源還沒來得及關閉也就是run方法還沒有執行完就強制結束線程，會導致資源無法關閉
        //t.stop();也是結束某個線程，這種方式比interrupt()更粗暴
        t.flag = false;
    }
}
class Thread2 extends Thread{
    boolean flag = true; //用這種方式結束線程很不錯，用一個變量控制run方法什么時候不再執行，不會出現run方法沒有執行完畢就結束
    @Override
    public void run() { //run方法一結束，整個線程就終止了
        while(flag){
            System.out.println("---"+new Date()+"---");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
    }
}

 

　　②join():指等待t線程終止。也可以理解為將t線程合並到當前線程來，等待t線程結束后再往下執行。相當於方法調用

package com.thread;

import java.util.Date;

/*
 * t.join()方法指等待t線程終止。也可以理解為將t線程合並到當前線程來，等待t線程結束后再往下執行。相當於方法調用
 */
public class TestJoin {
    public static void main(String[] args) {
        Thread t = new Thread3("abc");
        t.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我是main線程");
            if(i==10){
                try {
                    t.join();
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Thread3 extends Thread{
    public Thread3(String s) { //給該線程取一個名字，用getName()方法可以去到該名字
        super(s);
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我是"+getName()+"線程");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

運行該程序結果為：

我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是main線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是abc線程
我是main線程
我是main線程
我是main線程
我是main線程
我是main線程
我是main線程
我是main線程
我是main線程
我是main線程

可以看到從第22行起就開始順序執行了，因為i=10的時候就將該形成合並了。

　　③yield():暫停當前正在執行的線程對象，並執行其他線程。

　　④setPriority(): 更改線程的優先級。

　　　　MIN_PRIORITY = 1
  　　   NORM_PRIORITY = 5
           MAX_PRIORITY = 10

package com.thread;


/*t.yield()暫停當前正在執行的線程對象，並執行其他線程。
 * 
 * MIN_PRIORITY 1
 * NORM_PRIORITY 5
 * MAX_PRIORITY 10
 */
public class TestYield {
    public static void main(String[] args) {
        Thread4 t1 = new Thread4("t1");
        Thread4 t2 = new Thread4("t2");
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.MIN_PRIORITY);
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        t1.start();
        t2.start();
        
    }
}
class Thread4 extends Thread{
    public Thread4(String s) { 
        super(s);
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是"+getName()+"線程"+i);
            if(i%10 == 0){
                yield();
            }
        }
    }
}

由於運行結果太長就沒有貼上來了，運行該程序，可以看到t1和t2兩個進程每次當i為10的倍數時都會讓給其他線程執行。

　　⑤interrupt():中斷某個線程，這種結束方式比較粗暴，如果t線程打開了某個資源還沒來得及關閉也就是run方法還沒有執行完就強制結束線程，會導致資源無法關閉

　　要想結束進程最好的辦法就是用sleep()函數的例子程序里那樣，在線程類里面用以個boolean型變量來控制run()方法什么時候結束，run()方法一結束，該線程也就結束了。

　　⑥還有很多的方法就不一一列舉了.........

　　

　　當然，多線程難點不在這些，多線程的難點在於多線程之間的協調。關於多線程的協調待續........