1. package practice;
   
2. 
   
3. /**
   
4. * 多线程
   
5. *
   
6. * 1.几个概念：
   
7. *                 进程：在执行的程序。
   
8. *                         每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做一个控制单元。
   
9. *                 线程：就是进程中一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。
   
10. *                 *JVM启动时会有一个进程java.exe。该进程中至少有个线程负责java程序的执行。
    
11. *                    该线程运行代码存在于main方法中，该线程称之为主线程。
    
12. *                    其实，JVM启动不止一个线程，还有负责垃圾回收机制的线程。
    
13. *
    
14. * 2.线程的创建方式：
    
15. *                 第一种方式：（1）继承Thread类。
    
16. *                                 （2）复写Thread类中的run方法。
    
17. *                                         目的：将自定义代码存储在run方法，让线程运行。
    
18. *                                 （3） 调用线程的start方法，该方法里有两个作用：启动线程，调用run方法。
    
19. *                 第二种方式：实现Runnable接口。
    
20. *                                 （1）定义类实现Runnable接口。
    
21. *                                 （2）覆盖Runnable接口中的run方法。
    
22. *                                 （3）通过Thread类建立线程对象。
    
23. *                                 （4）将Runnable接口的子类对象作为实际参数传递给Thread类。
    
24. *                                 （5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
    
25. *                 ***两种方式的区别：        （1）实现方式避免了单继承的局限性，在定义线程时建议实现方式。
    
26. *                                                 （2）继承Thread，线程代码存放在Thread子类run方法中。
    
27. *                                                         实现runnable，线程代码存放在接口子类的run方法中。
    
28. *
    
29. * 3.多线程特性：随机性。
    
30. *
    
31. * 4.多线程的安全问题：
    
32. *                 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，
    
33. *                                 另一个线程参与进来执行，导致共享数据的错误。
    
34. *                 解决办法：        对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以执行。
    
35. *                                 Java对多线程问题进行了专业的解决方式：
    
36. *                                 （1）同步代码块：
    
37. *                                 synchronized(对象){需要被同步的代码}       
    
38. *                                 （2）也可以作为修饰符，锁是this。
    
39. *                                 如果同步函数被静态修饰后，使用的锁是该方法所在类的字节码文件对象，即类名.class。
    
40. *                                 --------------------------------       
    
41. *                                 同步的前提：1.必须要有两个或以上的线程。
    
42. *                                                 2.必须是多个线程使用同一个锁。
    
43. *                                 优点：解决了多线程的安全问题。
    
44. *                                 缺点：多线程需要判断锁，较为消耗资源。
    
45. * @author Qihuan
    
46. *
    
47. */
    
48. 
    
49. class PrimeThread implements Runnable {
    
50.        
    
51.         private int ticket = 100;
    
52.         Object obj = new Object();
    
53.         public void run() {
    
54.                 while(true){
    
55.                        
    
56.                         synchronized(obj){
    
57.                                 if(ticket > 0){
    
58.                                         try {
    
59.                                                 Thread.sleep(20);
    
60.                                         } catch (InterruptedException e) {
    
61.                                                 // TODO Auto-generated catch block
    
62.                                                 e.printStackTrace();
    
63.                                         }
    
64.                                         System.out.println(Thread.currentThread().getName()+" ------ "+ticket--);
    
65.                                 }else{
    
66.                                         break;
    
67.                                 }
    
68.                         }
    
69.                 }
    
70.         }
    
71. }
    
72. 
    
73. public class ThreadPractice {
    
74.         public static void main(String[] args) {
    
75.                 PrimeThread pt = new PrimeThread();
    
76.                 new Thread(pt).start();
    
77.                 new Thread(pt).start();
    
78.                 new Thread(pt).start();
    
79.                 new Thread(pt).start();
    
80.         }
    
81. }
    

复制代码

1. package practice;
   
2. 
   
3. /**
   
4. * 多线程
   
5. *
   
6. * 1.几个概念：
   
7. *                 进程：在执行的程序。
   
8. *                         每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做一个控制单元。
   
9. *                 线程：就是进程中一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。
   
10. *                 *JVM启动时会有一个进程java.exe。该进程中至少有个线程负责java程序的执行。
    
11. *                    该线程运行代码存在于main方法中，该线程称之为主线程。
    
12. *                    其实，JVM启动不止一个线程，还有负责垃圾回收机制的线程。
    
13. *
    
14. * 2.线程的创建方式：
    
15. *                 第一种方式：（1）继承Thread类。
    
16. *                                 （2）复写Thread类中的run方法。
    
17. *                                         目的：将自定义代码存储在run方法，让线程运行。
    
18. *                                 （3） 调用线程的start方法，该方法里有两个作用：启动线程，调用run方法。
    
19. *                 第二种方式：实现Runnable接口。
    
20. *                                 （1）定义类实现Runnable接口。
    
21. *                                 （2）覆盖Runnable接口中的run方法。
    
22. *                                 （3）通过Thread类建立线程对象。
    
23. *                                 （4）将Runnable接口的子类对象作为实际参数传递给Thread类。
    
24. *                                 （5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
    
25. *                 ***两种方式的区别：        （1）实现方式避免了单继承的局限性，在定义线程时建议实现方式。
    
26. *                                                 （2）继承Thread，线程代码存放在Thread子类run方法中。
    
27. *                                                         实现runnable，线程代码存放在接口子类的run方法中。
    
28. *
    
29. * 3.多线程特性：随机性。
    
30. *
    
31. * 4.多线程的安全问题：
    
32. *                 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，
    
33. *                                 另一个线程参与进来执行，导致共享数据的错误。
    
34. *                 解决办法：        对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以执行。
    
35. *                                 Java对多线程问题进行了专业的解决方式：
    
36. *                                 （1）同步代码块：
    
37. *                                 synchronized(对象){需要被同步的代码}       
    
38. *                                 （2）也可以作为修饰符，锁是this。
    
39. *                                 如果同步函数被静态修饰后，使用的锁是该方法所在类的字节码文件对象，即类名.class。
    
40. *                                 --------------------------------       
    
41. *                                 同步的前提：1.必须要有两个或以上的线程。
    
42. *                                                 2.必须是多个线程使用同一个锁。
    
43. *                                 优点：解决了多线程的安全问题。
    
44. *                                 缺点：多线程需要判断锁，较为消耗资源。
    
45. * @author Qihuan
    
46. *
    
47. */
    
48. 
    
49. class PrimeThread implements Runnable {
    
50.        
    
51.         private int ticket = 100;
    
52.         Object obj = new Object();
    
53.         public void run() {
    
54.                 while(true){
    
55.                        
    
56.                         synchronized(obj){
    
57.                                 if(ticket > 0){
    
58.                                         try {
    
59.                                                 Thread.sleep(20);
    
60.                                         } catch (InterruptedException e) {
    
61.                                                 // TODO Auto-generated catch block
    
62.                                                 e.printStackTrace();
    
63.                                         }
    
64.                                         System.out.println(Thread.currentThread().getName()+" ------ "+ticket--);
    
65.                                 }else{
    
66.                                         break;
    
67.                                 }
    
68.                         }
    
69.                 }
    
70.         }
    
71. }
    
72. 
    
73. public class ThreadPractice {
    
74.         public static void main(String[] args) {
    
75.                 PrimeThread pt = new PrimeThread();
    
76.                 new Thread(pt).start();
    
77.                 new Thread(pt).start();
    
78.                 new Thread(pt).start();
    
79.                 new Thread(pt).start();
    
80.         }
    
81. }
    

复制代码