Java基础---第十一天 多线程

一、多线程 概述

    1、进程：是一个正在执行中的程序。
        (1)、每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
    2、线程：就是进程中的一个独立的控制单元
        (1)、线程控制着进程的执行。
        (2)、一个进程中，至少有一个线程
    3、Java VM 启动的时候会有一个进程 java.exe
        (1)、该进程中至少有一个线程负责 java 程序的执行
        (2)、而且这个线程运行的代码存在于 main 方法中
        (3)、该线程称为主线程
    4、扩展：其实更细节说明 jvm ，jvm 启动不止一个线程，还有负责垃圾回收机制的线程
二、创建线程-继承Thread类
    1、一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
        (1)、定义类继承 Thread 
        (2)、复写 Thread 类中的 run 方法
            [1]、目的：将自定义代码存储在 run 方法周中，让线程运行
        (3)、调用线程的 start 方法，该方法有两个作用：启用线程，调用 run 方法
        (4)、发现运行结果每次都不同，因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行
        (5)、明确一点，在某一时刻，只能有一个程序在运行，(多核除外)
        (6)、cpu在做着快速的切换，一道道看上去是同时运行的效果，
        (7)、我们可以形象吧多线程运行行为在互相抢夺，cpu 执行权
        (8)、这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，cpu说的算
    2、例子

[java]  view plain copy

1. class ThreadDemo extends Thread{  
2.     // PrimeRun(long minPrime) {  
3.         // this.minPrime = minPrime;  
4.     // }  
5.     public void run(){  
6.         for(int x=0;x<60;x++){  
7.             System.out.println("ThreadDemo ru："+x);  
8.         }  
9.     }  
10. }  
11. public class Demo{  
12.     public static void main(String[] args){  
13.         ThreadDemo d = new ThreadDemo();  
14.         d.start();  
15.         for(int x=0;x<60;x++){  
16.             System.out.println("Demo run："+x);  
17.         }  
18.     }  
19. }  

三、创建线程-run和start特点
    1、为什么要覆盖 run 方法呢，thread 类用于描述线程
        (1)、该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是 run 方法
        (2)、也就是说 Thread 类中的 run 方法，用于存储线程要运行的代码            
四、线程练习
    1、例子

[java]  view plain copy

1. /* 
2. 创建两个线程，和主线程交替运行。 
3. */  
4. class ThreadDemo extends Thread{  
5.     ThreadDemo(String name){  
6.         super(name);  
7.     }  
8.     public void run(){  
9.         for(int x=0;x<60;x++){  
10.             System.out.println(this.getName()+" Thread ："+x);  
11.         }  
12.     }  
13. }  
14. public class Demo{  
15.     public static void main(String[] args){  
16.         ThreadDemo d1 = new ThreadDemo("one");  
17.         ThreadDemo d2 = new ThreadDemo("two");  
18.         d1.start();  
19.         d2.start();  
20.         for(int x=0;x<60;x++){  
21.             System.out.println("main Thread："+x);  
22.         }  
23.     }  
24. }  

五、线程运行状态
    1、
六、获取线程对象以及名称
    1、线程都有自己默认的名称：Thread-编号 ，该编号从0开始
    2、currentThread()：返回对当前正在执行的线程对象的引用。
    3、getName()：获取线程名称
    4、setName() 或者 构造函数：设置线程的名称
七、售票的例子

[java]  view plain copy

1. /* 
2. 需求：简单的卖票程序 
3. 多个窗口卖票 
4. */  
5. class Ticket extends Thread{  
6.     private static int tick = 100;  
7.     public void run(){  
8.         while(true){  
9.             if(tick>0){  
10.                 System.out.println(Thread.currentThread().getName()+" sale："+tick--);  
11.             }  
12.         }  
13.     }  
14. }  
15. public class Demo{  
16.     public static void main(String[] args){  
17.         Ticket t1 = new Ticket();  
18.         Ticket t2 = new Ticket();  
19.         Ticket t3 = new Ticket();  
20.         Ticket t4 = new Ticket();  
21.         t1.start();  
22.         t2.start();  
23.         t3.start();  
24.         t4.start();  
25.     }  
26. }  

八、创建线程-实现Runnable接口
    1、创建线程的第二种方式：实现 Runable 接口
        (1)、定义类实现 Runnable接口
        (2)、覆盖 Runnable 接口中的 run 方法,将线程要运行的代码存放在该 run 方法中
        (3)、通过 Thread 类建立线程对象
        (4)、将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数
            [1]、为什么要将 Runnable 接口的子类对象传递给 Thread 的构造函数，因为自定义的 run 方法所属的对象是 Runnable 接口的子类对象，所以要让线程去指定对象的 run 方法
        (5)、调用 Thread 类的 start 方法开启线程并调用 Runnable 接口子类的 run 方法

[java]  view plain copy

1. /* 
2. 需求：简单的卖票程序 
3. 多个窗口卖票 
4. */  
5. class Ticket implements Runnable{  
6.     private int tick = 100;  
7.     public void run(){  
8.         while(true){  
9.             if(tick>0){  
10.                 System.out.println(Thread.currentThread().getName()+" sale："+tick--);  
11.             }  
12.         }  
13.     }  
14. }  
15. public class Demo{  
16.     public static void main(String[] args){  
17.         Ticket t = new Ticket();  
18.         Thread t0 = new Thread(t);  
19.         Thread t1 = new Thread(t);  
20.         Thread t2 = new Thread(t);  
21.         Thread t3 = new Thread(t);  
22.         t0.start();  
23.         t1.start();  
24.         t2.start();  
25.         t3.start();  
26.     }  
27. }  

    2、实现方式和继承方式有什么区别
        (1)、实现方式好处：避免了单继承的局限性
        (2)、在定义线程时：建议使用实现方式
        (3)、两种方式区别：
            [1]、继承 Thread：线程代码存放在 Thread 子类 run 方法中
            [2]、实现 Runnable：线程代码存放在接口的子类的 run 方法中
九、多线程的安全问题
    1、对多条操作共享数据的语句，只能让一个线程都执行完，再执行过程中，不可以参与执行。
    2、java对于多线程的安全，提供了专业解决方式：
        (1)、就是同步代码块
        (2)、synchronized(){}
    3、

[java]  view plain copy

1. /* 
2. 需求：简单的卖票程序 
3. 多个窗口卖票 
4. */  
5. class Ticket implements Runnable{  
6.     private int tick = 10000;  
7.     Object obj = new Object();  
8.     public void run(){  
9.         while(true){  
10.             synchronized(obj){  
11.                 if(tick>0){  
12.                     System.out.println(Thread.currentThread().getName()+" sale："+tick--);  
13.                 }  
14.             }  
15.         }  
16.     }  
17. }  
18. public class Demo{  
19.     public static void main(String[] args){  
20.         Ticket t = new Ticket();  
21.         Thread t0 = new Thread(t);  
22.         Thread t1 = new Thread(t);  
23.         Thread t2 = new Thread(t);  
24.         Thread t3 = new Thread(t);  
25.         t0.start();  
26.         t1.start();  
27.         t2.start();  
28.         t3.start();  
29.     }  
30. }  

十、多线程同步代码块
    1、对象如同锁，持有所得线程可以在同步中执行。
    2、没有持有锁的线程即使获取 cpu 的执行权，也进不去，因为没有获取锁
    3、火车上的卫生间----经典
    4、同步的前提
        (1)、必须要有两个或者两个以上的线程
        (2)、必须是多个线程使用同一个锁
        (3)、必须保证同步过程中必须有一个线程在运行
    5、弊端
        (1)、多个线程需要判断锁，较为消耗资源
十一、多线程-同步函数
    1、synchronized 作为修饰符号，放在函数上

[java]  view plain copy

1. /* 
2. 需求：银行有一个金库 
3. 有两个储户分别存300元，每次存100，存3次 
4. 目的：改程序，是否有安全问题 
5.  
6.  
7. 如何找问题： 
8.     1、明确哪些代码是多线程运行代码 
9.     2、明确共享数据 
10.     3、明确多线程运行代码中哪些语句是操作共享数据的 
11. */  
12. class Bank{  
13.     private int sum;  
14.     Object obj = new Object();  
15.     public synchronized void add(int n){  
16.         sum = sum + n;  
17.         System.out.println("sunm = "+sum);  
18.     }  
19. }  
20. class Cus implements Runnable{  
21.     private Bank b = new Bank();  
22.     public void run(){  
23.         for(int x=0;x<3;x++){  
24.             b.add(100);  
25.         }  
26.     }  
27. }  
28. public class Demo{  
29.     public static void main(String[] args){  
30.         Cus c = new Cus();  
31.         Thread c0 = new Thread(c);  
32.         Thread c1 = new Thread(c);  
33.         c0.start();  
34.         c1.start();  
35.     }  
36. }  

十二、多线程-同步函数的锁是this
    1、同步函数用的是哪一个锁呢？
    2、函数需要被对象调用。那么函数都有一个所属对象引用。就是this
    3、所以同步函数使用的所是this
十三、多线程-静态同步函数的锁是Class对象
    1、如果同步函数被静态修饰后，使用的锁是什么呢？
    2、通过验证，发现不再是 this ，因为静态方法中也不可以定义 this
    3、静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，
    4、类名.class 该对象的类型是Class
    5、静态的同步方法，使用的锁是该方法所在类的字节码文件对象  类名.class
十四、多线程-单例设计模式-懒汉式
    1、对象延迟加载
    2、多线程会有问题，使用同步锁，该类所在对象
   

[java]  view plain copy

1. public static Single getInstance(){  
2.        if(s==null){  
3.            synchronized(Single.class){  
4.                if(s==null){  
5.                    s = new Single();  
6.                }  
7.            }  
8.        }  
9.        return s;  
10.    }  

十五、多线程-死锁
    1、同步中嵌套同步

[java]  view plain copy

1. /* 
2. 需求：简单的卖票程序 
3. 多个窗口卖票 
4. */  
5. class Ticket implements Runnable{  
6.     private static int tick = 1000;  
7.     Object obj = new Object();  
8.     static boolean flag = true;  
9.     public void run(){  
10.         if(flag){  
11.             while(true){  
12.                 synchronized(obj){  
13.                     show();  
14.                 }  
15.             }  
16.         }else{  
17.             while(true){  
18.                 show();  
19.             }  
20.         }  
21.     }  
22.     public static synchronized void show(){  
23.     flag = true;  
24.         synchronized(obj){  
25.             if(tick>0){  
26.                         try{Thread.sleep(10);}catch(Exception e){}  
27.                 System.out.println(Thread.currentThread().getName()+" show："+tick--);  
28.             }  
29.         }  
30.     }  
31. }  
32. public class Demo{  
33.     public static void main(String[] args){  
34.         Ticket t = new Ticket();  
35.         Thread t0 = new Thread(t);  
36.         Thread t1 = new Thread(t);  
37.         t0.start();  
38.         try{Thread.sleep(10);}catch(Exception e){}  
39.         t.flag = false;  
40.         t1.start();  
41.     }  
42. }