黑马程序员__多线程1

------- android培训、java培训、期待与您交流！ ----------

1. 进程

  |-- 就是一个应用程序，在内存中的所占区域


2. 线程
  |-- 就是进程中的一条执行路径，看做是进程中的小子程序
  |-- 提高的程序的运行效率，可以保证多个线程一起运行


3. 虚拟机，肯定多线程程序


4. 建立线程的第一种方法(了解)
  |-- 继承Thread类
  |-- 覆盖掉run方法
  |-- 建立Thread子类对象
  |-- 调用start方法


5. 线程的随机性
  |-- CPU控制线程的执行
  |-- CPU进行线程中的切换，随机性，我们控制不了


6. 线程的状态图(*********)


7. 售票的实例，引出了第二种创建线程的方式(*******)
  |-- 实现Runnable接口，覆盖run方法
  |-- 建立Thread类对象，传递实现Runnable接口的子类对象
  |-- 调用Thread类中的run方法
  |-- 第二种方式，可以实现对象中的数据共享
  |-- 避免的单继承的局限性

[java]  view plain copy

1. /* 
2.   售票 票数量是固定的 100张 
3.     火车站卖 ，代售点 
4.  
5.     使用多线程技术，模拟窗口的售票(4个窗口，线程) 
6.  
7.     4个线程对象，每个对象中，都有100张票，数据错乱了 
8.     解决：这些对象，需要共享100张票  static 
9.  
10.     静态的生命太长了 
11.  
12.     建立线程的第二个方法(********) 
13.     步骤： 
14.       建立实现Runnable接口的实现类 
15.       重写了run方法 
16.       创建Thread类对象，传递Runnable接口的子类对象 
17.       调用Thread类中的start方法 
18.       start方法开启线程，并调用Runnable接口子类对象中的run方法 
19.  
20.   继承Thread类，和实现Runnable接口的区别 
21.    1. 实现Runnable接口的方式，可以共享数据‘ 
22.    2. 避免了继承的局限性 
23.  
24.  
25.    Thread t1 = new Thread(t) 
26.    public Thread(Runnable target)多态 Runnable target = new Ticket(); 
27.  
28.    线程中，最倒霉的事情，就是安全隐患 
29.    1. 一个数据被多线程操作 
30.    2. 这个数据，是多线程的共享数据 
31. */  
32. class Ticket implements Runnable  
33. {  
34.     private  int ticket = 100;  
35.     public void run()  
36.     {  
37.          while(true)  
38.            {  
39.              if(ticket>0)  
40.              {  
41.                 try  
42.                {  
43.                   Thread.sleep(10);   
44.                }  
45.                catch (Exception e)  
46.                {  
47.                }      
48.               System.out.println(Thread.currentThread().getName()+"  以出售第  "+ticket--);  
49.              }  
50.        }  
51.     }  
52. }  
53. /* 
54. class Ticket extends Thread 
55. { 
56.     private static int ticket = 100; 
57.     public void run() 
58.     { 
59.       while(true) 
60.        { 
61.          if(ticket>0) 
62.           { 
63.             System.out.println(getName()+"  以出售第  "+ticket--); 
64.           } 
65.        } 
66.     } 
67. }*/  
68. class  ThreadDemo2  
69. {  
70.     public static void main(String[] args)   
71.     {  
72.         Ticket t = new Ticket();//创建了一个线程？？不是  
73.         Thread t1 = new Thread(t);//创建了一个线程  
74.         Thread t2 = new Thread(t);//创建了一个线程  
75.         Thread t3 = new Thread(t);//创建了一个线程  
76.         Thread t4 = new Thread(t);//创建了一个线程  
77.   
78.         t1.start();  
79.         t2.start();  
80.         t3.start();  
81.         t4.start();  
82.           
83.         /* 
84.         Ticket t1 = new Ticket(); 
85.         Ticket t2 = new Ticket(); 
86.         Ticket t3 = new Ticket(); 
87.         Ticket t4 = new Ticket(); 
88.         t1.start(); 
89.         t2.start(); 
90.         t3.start(); 
91.         t4.start(); 
92.         */  
93.     }  
94. }  

[java]  view plain copy

1. /* 
2.   如何解决错票问题 
3.   如何搞定多线程的安全隐患 
4.  
5.   原理，一个线程运行结束后，才能允许后面的线程进来运行 
6.  
7.   介绍一个新的关键字  synchronized 同步   
8.   应用在什么地方，应用在线程操作的共享数据中 
9.  
10.   同步的固定格式：同步代码块 
11.   synchronized(对象----任意的对象都行) 
12.   { 
13.    
14.     线程操作的共享数据 
15.   } 
16.  
17.   解决安全为题，但是仍然数据错乱 
18.    1. 是不是多线程的程序 
19.    2. 这些线程是不是持有同一把锁 
20.  */  
21. class Ticket implements Runnable  
22. {  
23.       
24.     private  int ticket = 100;     
25.     Object obj = new Object();  
26.     public void run()  
27.     {  
28.       while(true)  
29.        {    
30.            synchronized(obj)  
31.            {  
32.              if(ticket>0)  
33.              {  
34.                 try  
35.                {  
36.                   Thread.sleep(10);   
37.                }  
38.                catch (Exception e)  
39.                {  
40.                }      
41.               System.out.println(Thread.currentThread().getName()+"  以出售第  "+ticket--);  
42.              }  
43.            }  
44.        }  
45.     }  
46. }  
47.   
48. class  ThreadDemo3  
49. {  
50.     public static void main(String[] args)   
51.     {  
52.         Ticket t = new Ticket();//创建了一个线程？？不是  
53.         Thread t1 = new Thread(t);//创建了一个线程  
54.         Thread t2 = new Thread(t);//创建了一个线程  
55.         Thread t3 = new Thread(t);//创建了一个线程  
56.         Thread t4 = new Thread(t);//创建了一个线程  
57.   
58.         t1.start();  
59.         t2.start();  
60.         t3.start();  
61.         t4.start();  
62.           
63.         /* 
64.         Ticket t1 = new Ticket(); 
65.         Ticket t2 = new Ticket(); 
66.         Ticket t3 = new Ticket(); 
67.         Ticket t4 = new Ticket(); 
68.         t1.start(); 
69.         t2.start(); 
70.         t3.start(); 
71.         t4.start(); 
72.         */  
73.     }  
74. }  

8. 安全问题


9. 同步代码块
    synchronized(this)  ****同步
    {
    }


    synchronized(类名.class)
    {
    }


10. 安全问题的解决
  |-- 数据被多个线程访问
  |-- 这些线程是不是持有同一把锁


11. 死锁的案例(*******)
  |-- 记住代码，面试

[java]  view plain copy

1. //开发不可能，面试常问  
2. /* 
3.   死锁实例 
4.    造2把锁 A B  
5.    
6.   产生了同步嵌套 
7. */  
8. class Dead implements Runnable  
9. {  
10.     boolean b = false;  
11.     public void run()  
12.     {  
13.        while(true)  
14.         {  
15.             if(b)  
16.             {  
17.                synchronized(LockA.locka)//2 locka  
18.                 {  
19.                    System.out.println("if...locka");//2 locka  
20.                      synchronized(LockB.lockb)  
21.                     {  
22.                       System.out.println("if...lockb");   
23.                     }  
24.                 }  
25.             }  
26.             else  
27.             {  
28.                synchronized(LockB.lockb)//1 lockb  
29.                 {  
30.                   System.out.println("else...lockb");// lockb  
31.                    synchronized(LockA.locka)  
32.                     {  
33.                       System.out.println("else...locka");  
34.                     }  
35.                 }  
36.             }  
37.            
38.         }  
39.     }  
40. }  
41.   
42. class LockA  
43. {  
44.     public static LockA locka = new LockA();  
45. }  
46. class LockB  
47. {  
48.     public static LockB lockb = new LockB();  
49. }  
50. class DeadLock   
51. {  
52.     public static void main(String[] args)   
53.     {  
54.         Dead d1 = new Dead();//false  
55.         Thread t1= new Thread(d1);  
56.   
57.         Dead d2 = new Dead();//true  
58.         d2.b=true;  
59.         Thread t2 =new Thread(d2);  
60.   
61.         t1.start();  
62.         t2.start();  
63.     }  
64. }  

12. 安全高效的懒汉式(******) 面试

[java]  view plain copy

1. class Single  
2. {  
3.     private Single(){}  
4.     private static Single s = null;  
5.   
6.     public static Single getInstance()  
7.     {  
8.         if(s==null)  
9.         {  
10.         synchronized(Single.class)  
11.         {  
12.           if(s==null)  
13.            {  
14.              try{Thread.sleep(15);}catch(Exception e){}  
15.              s = new Single();  
16.            }  
17.           return s;  
18.         }  
19.       }  
20.       return s;  
21.     }  
22. }   
23.   
24. class TestSingle implements Runnable  
25. {  
26.     public void run()  
27.     {  
28.       while(true)  
29.         {  
30.            Single s = Single.getInstance();  
31.            System.out.println(s);  
32.         }  
33.     }  
34. }  
35. class  SafeSingle  
36. {  
37.     public static void main(String[] args)   
38.     {  
39.         TestSingle t = new TestSingle();  
40.         Thread t1 = new Thread(t);  
41.         Thread t2 = new Thread(t);  
42.           
43.   
44.         t1.start();  
45.         t2.start();  
46.           
47.   
48.     }  
49. }  

13. Thread方法
 |-- run负责线程中运行的代码
 |-- Thread(String name),构造的时候，传递线程名
 |-- getName()获取线程名
 |-- setName()设置线程名
 |-- Thread.currentThread().getName()获取线程名，在非Thread子类中使用

 |-- start()开启线程，JVM调用线程的run方法

------- android培训、java培训、期待与您交流！ ----------