多線程詳解和代碼測試

1:多線程
(1)多線程：一個應用程序有多條執行路徑
進程：正在執行的應用程序。

             是系統進行資源分配和調用的獨立單元。每一個進程都有他自己的內存空間和系統資源
線程：進程的執行單元，執行路徑。

              在同一個進程內又可以執行多個任務，而這每一個任務就可以視為一個線程。
單線程：一個應用程序只有一條執行路徑
多線程：一個應用程序有多條執行路徑

多進程的意義?
提高CPU的使用率

多線程的意義?
提高應用程序的使用率

(2)Java程序的運行原理及JVM的啟動是多線程的嗎?
A:Java命令去啟動JVM，JVM會啟動一個進程，該進程會啟動一個主線程。
B:JVM的啟動是多線程的，因為它最低有兩個線程啟動了，主線程和垃圾回收線程。

(3)多線程的實現方案
A:繼承Thread類

/*
 * java提供兩兩種方式實現多線程程序
 * 
 * 方式一：繼承Thred類
 * 步驟：自定義MyThread類 繼承Thred類 
 *     MyThread類里面重寫run()?
 *        這里要明白為什么是run方法
 *     創建對象
 *     啟動線程
 *     
 */
public class MyThreadDemo {
    public static void main(String[] args) {
        //創建線程對象
        //MyThread my = new MyThread();
        //啟動線程
        //my.run();
        //my.run();
        /*
         * 調用run()方法為什么是單線程的？
         * 由於run()方法直接調用其實就相當於普通的方法調用，所有是單線程的效果
         * 可以通過start()方法來實現多線程
         * 
         * 這里要明白run()和start()的區別：
         * run()：僅是封裝被線程執行的代碼，直接調用屬於普通方法
         * start()：先啟動線程，然后再通過jvm去調用該線程的run()方法
         */
        
        //創建兩個線程
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        my1.start();
        my2.start();
    }

}

 

/*
 * 這個類要重寫run()方法，是因為，不是說類中的所有代碼都需要被線程執行。
 * 這時為了區分哪些代碼能夠被線程執行，Java就提供了Thread類中的run()方法
 * 來包含哪些需要被線程執行的代碼
 */
public class MyThread extends Thread{
    @Override
    public void run(){
        for(int x = 0; x < 100; x++){
            System.out.println(x);
        }
    }

}

 

獲取線程名稱

/*
 * 獲取線程對象名稱
 */
public class MyThredDemo1 {
    public static void main(String[] args) {
        //帶參構造方法給線程起名字
        MyThread1 my1 = new MyThread1("a");
        MyThread1 my2 = new MyThread1("b");
        
        //調用方法設置名稱
        //my1.setName("a");
        //my2.setName("b");
        
        my1.start();
        my2.start();
        
        //獲取main方法所在線程名稱
        System.out.println(Thread.currentThread().getName());
    }

}

 

public class MyThread1 extends Thread{

    public  MyThread1() {
        
    }
    
    public  MyThread1(String name) {
        
    }
    
    @Override
    public void run(){
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
    }
}

 

B:實現Runnable接口(一般都會采用方式二)

/*
 * 多線程實現方式2：實現Runnable接口
 * 步驟：1.自定義類MyRunnable實現Runnable接口
 *     2.重寫run()方法
 *     3.創建MyRunnable類的對象
 *     4.創建Thread類的對象，並把3步驟的對象作為構造參數傳遞
 */
public class MyRunnableDemo {
     public static void main(String[] args) {
         //創建MyRunnable類的對象
        MyRunnable my = new MyRunnable();
        
        //創建Thread類的對象，並把3步驟的對象作為構造參數傳遞
        //Thread(Runnale target)
        //Thread t1 = new Thread(my);
        //Thread t2 = new Thread(my);
        //t1.setName("aa");
        //t2.setName("bb");
        
        //Thread(Runnable target, String name) 另一種方法命名
        Thread t1 = new Thread(my, "aa");
        Thread t2 = new Thread(my, "bb");
        
        t1.start();
        t2.start();
   }
}

public class MyRunnable implements Runnable {
/*
 * 1.自定義類MyRunnable實現Runnable接口
 * 2.重寫run()方法
 * 
 */
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            //由於實現接口的方法不能直接Thread類的方法，這時需要間接使用
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }

    }

}

 

小結：

實現多線程的方式：兩種

方式一：繼承Thread類

步驟：1.自定義類MyThread繼承Thread類

           2.在MyThread類中重寫run()方法

           3.創建MyThread類的對象

           4.啟動線程對象

 

方式二：實現Runnable接口

步驟：1.自定義類MyRunnble實現Runnable接口

           2.MyRunnble里面重寫run()方法

           3.創建MyRunnble類的對象

           4.創建Thread類的對象，並把3步驟的對象作為構造參數傳遞

問題：有了方式一了，為什么還要方式二呢？

          1.可以避免由於Java單繼承帶來的局限性

          2.適合多個相同程序的代碼去處理同一個資源的情況，將線程和程序的代碼、數據分離，充分體現了面向對象的設計思想。

 

(4)線程的調度和優先級問題
    A:線程的調度
      a:分時調度
      b:搶占式調度 (Java采用的是該調度方式)
   B:獲取和設置線程優先級
      a:默認是5
      b:范圍是1-10

/*
 * 獲取線程的優先級
 *    public final int getPriority():返回線程的優先級
 *    
 * 設置線程對象的優先級
 *    public final void setPriority():設置線程優先級
 *    
 * 注意：線程默認的優先級是5
 *     線程優先級范圍是：1-10
 *     優先級高僅表示線程獲取CPU時間片的幾率高，這要求次數比較多或者多次運行才能看到好的效果
 *     
 */
public class ThreadPriorityDemo {

    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        
        tp1.setName("aa");
        tp1.setName("bb");
        tp1.setName("cc");
        
        //獲取默認優先級
        System.out.println(tp1.getPriority());
        System.out.println(tp2.getPriority());
        System.out.println(tp3.getPriority());
        
        //設置優先級
        tp1.setPriority(10);
        tp2.setPriority(1);
        
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

public class ThreadPriority extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
        
    }

}

 

(5)線程的控制(常見方法)
A:休眠線程

//線程睡眠  public static void sleep(long millis)
public class ThreadSleepDemo {
 
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        
        //設置線程名稱
        ts1.setName("a");
        ts2.setName("b");
        ts3.setName("c");
        
        //啟動線程
        ts1.start();
        ts2.start();
        ts3.start();
        
    }
    
}

public class ThreadSleep extends Thread {

    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x + ",時間:" + new Date());
            //睡眠
            try {
                Thread.sleep(1000);//睡眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

 

B:加入線程

//public final void join():等待線程終止
public class ThreadJoinDemo {

    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        
        tj1.setName("aa");
        tj2.setName("bb");
        tj3.setName("cc");
        
        tj1.start(); 
        //等待tj1執行完
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        tj2.start();
        tj3.start();
        
    }
}

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);

        }
    }
}

 

C:禮讓線程

/*
 * public static void yield():暫停當前正在執行的線程，並去執行其他線程
 * 可以讓多個線程更加和諧，但是還不能保證完全均勻
 */
public class ThreadYieldDemo {
    public static void main(String[] args) {
        ThreadYield ty1 = new ThreadYield();
        ThreadYield ty2 = new ThreadYield();
        
        ty1.setName("a");
        ty2.setName("b");
        
        ty1.start();
        ty2.start();
    }

}

public class ThreadYield extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);

            Thread.yield();
        }
    }

}

 

D:后台線程（守護線程）

/*
 * public final void setDaemon(boolean on)
 * 將該線程標記為守護線程或者用戶線程
 * 當正在運行的線程都是守護線程時，java虛擬機退出
 * 該方法必須在啟動前調用
 */
public class ThreadDaemonDemo {

    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        
        td1.setName("aa");
        td2.setName("bb");
        
        //設置守護線程
        td1.setDaemon(true);
        td2.setDaemon(true);
        
        td1.start();
        td2.start();
        
        //設置主類線程名稱
        Thread.currentThread().setName("dd");
        for(int x = 0; x < 5; x++){
            System.out.println(Thread.currentThread().getName() + ":" + x);
        }
    }
}

public class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for(int x = 0; x < 100; x++){
            System.out.println(getName() + ":" + x);
        }
    }

}

 

E:終止線程(掌握)

public class ThreadStopDemo {

    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        
        ts.start();
        
        try {
            Thread.sleep(3000);
            ts.interrupt();
        } catch (InterruptedException e) {
            
            e.printStackTrace();
        }
    }
}

public class ThreadStop extends Thread{
    @Override
    public void run() {
        System.out.println("開始時間：" + new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            
            //e.printStackTrace();
            System.out.println("線程被中斷");
        }
        
        System.out.println("結束時間：" + new Date());
    }

}

 

(6)線程的生命周期
A:新建
B:就緒
C:運行
D:阻塞
E:死亡

(7)電影院賣票程序的實現
A:繼承Thread類

//繼承Thread類來實現
public class SellTicketDemo {

    public static void main(String[] args) {
        //三個窗口  創建三個線程對象
        SellTicket st1 = new SellTicket();
        SellTicket st2 = new SellTicket();
        SellTicket st3 = new SellTicket();
        
        //設置線程對象名稱
        st1.setName("窗口1");
        st2.setName("窗口2");
        st3.setName("窗口3");
        
        //啟動線程
        st1.start();
        st2.start();
        st3.start();
    }
}

 

public class SellTicket extends Thread {

    //定義100張票
    //private int tickets = 100;
    //為了讓多個線程對象共享這100張票，將其用靜態修飾
    private static int tickets = 100;
    @Override
    public void run() {
        //定義100張票
        //這里每個線程進來都會走這里，相當於每個線程賣自己的100張票，將票數定義到外面
        //int tickets = 100;
        
        //表示電影院一直有票
        while(true){
            if(tickets > 0){
                System.out.println(getName() + "正在出售第：" + (tickets--) + "張票");
            }
        }
    }
}

 

B:實現Runnable接口（多線程問題一般采用這種方法）

//實現Runnable接口的方法
public class SellTicketDemo {

    public static void main(String[] args) {
        //創建資源對象
        SellTicket st = new SellTicket();
        
        //創建三個窗口（線程對象）
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        
        //啟動線程
        t1.start();
        t2.start();
        t3.start();
    }
}

public class SellTicket implements Runnable {
    //定義100張票
    private int tickets = 100;
    
    @Override
    public void run() {
        while(true){
            if(tickets > 0){
                System.out.println(Thread.currentThread()
                        .getName()+ "正在出售第：" + (tickets--) + "張票" );
            }
        }
    }

}

 

(8)電影院賣票程序出問題
A:為了更符合真實的場景，加入了休眠100毫秒。
B:加入休眠后賣票問題
a:同票多次賣

   因為CPU的一次操作必須是原子性的
b:負數票

   隨機性和延遲性導致

(9)多線程安全問題的原因

(也是以后判斷一個程序是否有線程安全問題的依據)
A:是否有多線程環境
B:是否有共享數據
C:是否有多條語句操作共享數據

 

(10)同步解決線程安全問題
A:同步代碼塊
synchronized(對象) {
    需要被同步的代碼;
}

    注意：同步可以解決安全問題的根本原因在於這個對象上面

               該對象如同鎖的功能。多個線程必須是同一把鎖。

//實現Runnable接口的方法
public class SellTicketDemo {

    public static void main(String[] args) {
        //創建資源對象
        SellTicket st = new SellTicket();
        
        //創建三個窗口（線程對象）
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        
        //啟動線程
        t1.start();
        t2.start();
        t3.start();
    }
}

 

 

public class SellTicket implements Runnable {
    //定義100張票
    private int tickets = 100;
    
    //創建鎖對象 同一把鎖
    private Object obj = new Object();
    
    @Override
    public void run() {
        while(true){
            synchronized (obj) {
            if(tickets > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread()
                        .getName()+ "正在出售第：" + (tickets--) + "張票" );
             }
         }
     }
   }
}

 

     這里的鎖對象可以是任意對象。

//實現Runnable接口的方法
public class SellTicketDemo {

    public static void main(String[] args) {
        //創建資源對象
        SellTicket st = new SellTicket();
        
        //創建三個窗口（線程對象）
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        
        //啟動線程
        t1.start();
        t2.start();
        t3.start();
    }
}

public class SellTicket implements Runnable {
    //定義100張票
    private int tickets = 100;
    
    //創建鎖對象 同一把鎖
    //private Object obj = new Object();
    //任意對象
    private Demo d = new Demo();
    @Override
    public void run() {
        while(true){
            synchronized (d) {
            if(tickets > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread()
                        .getName()+ "正在出售第：" + (tickets--) + "張票" );
             }
         }
     }
   }
}

class Demo{
    
}

 

 

B:同步方法
把同步加在方法上。

這里的鎖對象是this

//實現Runnable接口的方法
public class SellTicketDemo {

    public static void main(String[] args) {
        //創建資源對象
        SellTicket st = new SellTicket();
        
        //創建三個窗口（線程對象）
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        
        //啟動線程
        t1.start();
        t2.start();
        t3.start();
    }
}

public class SellTicket implements Runnable {
    //定義100張票
    private int tickets = 100;
    
    //創建鎖對象 同一把鎖
    //private Object obj = new Object();
    
    //任意對象
    private Demo d = new Demo();
    
    private int x = 0;
    @Override
    public void run() {
        while(true){
            if(x%2 == 0){
                synchronized (this) {
                    if(tickets > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread()
                                .getName()+ "正在出售第：" + (tickets--) + "張票" );
                     }
                 }
             
            }else{
                sellTicket();
            }
            x++;
            
     }
  }

  private synchronized void sellTicket() {
    
        if(tickets > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()
                    .getName()+ "正在出售第：" + (tickets--) + "張票" );
         }
     }
        
}

class Demo{
 }

 

C:靜態同步方法
把同步加在方法上。

這里的鎖對象是當前類的字節碼文件對象(反射再講字節碼文件對象)

 

//實現Runnable接口的方法
public class SellTicketDemo {

    public static void main(String[] args) {
        //創建資源對象
        SellTicket st = new SellTicket();
        
        //創建三個窗口（線程對象）
        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        
        //啟動線程
        t1.start();
        t2.start();
        t3.start();
    }
}

 

public class SellTicket implements Runnable {
    //定義100張票
    private static int tickets = 100;
    
    //創建鎖對象 同一把鎖
    //private Object obj = new Object();
    
    //任意對象
    private Demo d = new Demo();
    
    private int x = 0;
    @Override
    public void run() {
        while(true){
            if(x%2 == 0){
                synchronized (SellTicket.class) {
                    if(tickets > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread()
                                .getName()+ "正在出售第：" + (tickets--) + "張票" );
                     }
                 }
             
            }else{
                sellTicket();
            }
            x++;
            
     }
  }

  private static synchronized void sellTicket() {
    
        if(tickets > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()
                    .getName()+ "正在出售第：" + (tickets--) + "張票" );
         }
     }
        
}

class Demo{
 }

 

 

(11)回顧以前的線程安全的類
A:StringBuffer
B:Vector
C:Hashtable
D:如何把一個線程不安全的集合類變成一個線程安全的集合類
用Collections工具類的方法即可。

 

public class ThreadDemo3 {
public static void main(String[] args) {
    //線程安全的類
    StringBuffer sb = new StringBuffer();
    Vector<String> v = new Vector<String>();
    Hashtable<String, String> hsah = new Hashtable<String, String>();
    
    //Vector是線程安全的時候考慮使用。但即使安全也不會考慮使用
    //用下面這種安全的
    List<String> list1 = new ArrayList<String>();//線程不安全
    //線程安全
    List<String> list2 = Collections.synchronizedList(new ArrayList<String>());
 }
}