黑马程序员——JAVA多线程

----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ------

1:多线程
(1)多线程：一个应用程序有多条执行路径
进程：正在执行的应用程序
线程：进程的执行单元，执行路径
单线程：一个应用程序只有一条执行路径
多线程：一个应用程序有多条执行路径

多进程的意义?
提高CPU的使用率
多线程的意义?
提高应用程序的使用率
(2)Java程序的运行原理及JVM的启动是多线程的吗?
A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
(3)多线程的实现方案
A:继承Thread类
B:实现Runnable接口
(4)线程的调度和优先级问题
A:线程的调度
a:分时调度
b:抢占式调度 (Java采用的是该调度方式)
B:获取和设置线程优先级
a:默认是5
b:范围是1-10
(5)线程的控制(常见方法)
A:休眠线程
B:加入线程
C:礼让线程
D:后台线程
E:终止线程(掌握)
(6)线程的生命周期(参照 线程生命周期图解.bmp)
A:新建
B:就绪
C:运行
D:阻塞
E:死亡
(7)电影院卖票程序的实现
A:继承Thread类
B:实现Runnable接口
(8)电影院卖票程序出问题
A:为了更符合真实的场景，加入了休眠100毫秒。
B:卖票问题
a:同票多次
b:负数票
(9)多线程安全问题的原因(也是我们以后判断一个程序是否有线程安全问题的依据)
A:是否有多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据
(10)同步解决线程安全问题
A:同步代码块
synchronized(对象) {
需要被同步的代码;
}

这里的锁对象可以是任意对象。

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

这里的锁对象是this

C:静态同步方法
把同步加在方法上。

这里的锁对象是当前类的字节码文件对象

多线程程序示例：

1. class Demo extends Thread{
   
2.       private String name ;
   
3.       Demo(String name){
   
4.              this.name = name;
   
5.       }
   
6.        public void run(){
   
7.              for(int x = 0; x < 10; x++){
   
8.                   System.out.println(name + "...x=" + x + "...ThreadName=" + Thread.currentThread ().getName());
   
9.             }
   
10.       }
    
11. }
    
12. 
    
13. class ThreadDemo{
    
14.        public static void main(String[] args){
    
15.             Demo d1 = new Demo("旺财");
    
16.             Demo d2 = new Demo("xiaoqiang");
    
17.             d1.start(); //开启线程，调用run方法。
    
18.             d2.start();
    
19.             for(int x = 0; x < 20; x++){
    
20.                   System.out.println("x = " + x + "...over..." + Thread.currentThread().getName());
    
21.             }
    
22.       }
    
23. }

运行结果：

  P.S.
    1、可以通过Thread的getName方法获取线程的名称，名称格式：Thread-编号（从0开始）。
    2、Thread在创建的时候，该Thread就已经命名了。源码如下：

创建线程方式二：实现Runnable接口

1. 定义类实现Runnable接口。
    2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
    3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
    4. 调用线程对象的start方法开启线程。

    实现Runnable接口的好处：
    1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
    2. 避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

 示例：

1. /准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。
   
2. //通过接口的形式完成。
   
3. class Demo implements Runnable{
   
4.       public void run(){
   
5.             show();
   
6.       }
   
7.       public void show(){
   
8.              for(int x = 0; x < 20; x++){
   
9.                   System.out.println(Thread.currentThread().getName() + "..." + x);
   
10.              }
    
11.       }
    
12. }
    
13. 
    
14. class ThreadDemo{
    
15.        public static void main(String[] args){
    
16.             Demo d = new Demo();
    
17.             Thread t1 = new Thread(d);
    
18.             Thread t2 = new Thread(d);
    
19.             t1.start();
    
20.             t2.start();
    
21.        }
    
22. }

运行结果：

线程安全问题产生的原因

需求：模拟4个线程同时卖100张票。

代码：

1. class Ticket implements Runnable{
   
2.        private int num = 100;
   
3. 
   
4.        public void run(){
   
5.              while(true ){
   
6.                    if(num > 0){
   
7.                          try{
   
8.                               Thread. sleep(10);
   
9.                         } catch(InterruptedException e){
   
10.                               e.printStackTrace();
    
11.                         }
    
12.                         System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
    
13.                   }
    
14.             }
    
15.       }
    
16. }
    
17. 
    
18. class TicketDemo{
    
19.        public static void main(String[] args){
    
20.             Ticket t = new Ticket();
    
21.             Thread t1 = new Thread(t);
    
22.             Thread t2 = new Thread(t);
    
23.             Thread t3 = new Thread(t);
    
24.             Thread t4 = new Thread(t);
    
25. 
    
26.             t1.start();
    
27.             t2.start();
    
28.             t3.start();
    
29.             t4.start();
    
30.       }
    
31. }

运行结果：

 原因分析：

出现上图安全问题的原因在于Thread-0通过了if判断后，在执行到“num--”语句之前，num此时仍等于1。
CPU切换到Thread-1、Thread-2、Thread-3之后，这些线程依然可以通过if判断，从而执行“num--”的操作，因而出现了0、-1、-2的情况。

线程安全问题产生的原因：

1. 多个线程在操作共享的数据。
    2. 操作共享数据的线程代码有多条。
    当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。

线程安全问题的解决方案：

 思路：
    就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。
    必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

    在java中，用同步代码块就可以解决这个问题。
    同步代码块的格式：
    synchronized(对象){
           需要被同步的代码;
    } 

    同步的好处：解决了线程的安全问题。
    同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
    同步的前提：必须有多个线程并使用同一个锁。

  修改后代码：

1. class Ticket implements Runnable{
   
2.       private int num = 100;
   
3.       Object obj = new Object();
   
4. 
   
5.       public void run(){
   
6.              while(true ){
   
7.                    synchronized(obj ){
   
8.                          if(num > 0){
   
9.                               System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
   
10.                         }
    
11.                    } 
    
12.              }
    
13.       }
    
14. }
    
15. 
    
16. class TicketDemo{
    
17.        public static void main(String[] args){
    
18.             Ticket t = new Ticket();
    
19.             Thread t1 = new Thread(t);
    
20.             Thread t2 = new Thread(t);
    
21.             Thread t3 = new Thread(t);
    
22.             Thread t4 = new Thread(t);
    
23.             
    
24.             t1.start();
    
25.             t2.start();
    
26.             t3.start();
    
27.             t4.start();
    
28.       }
    
29. }

运行结果：

 原因分析：
   上图显示安全问题已被解决，原因在于Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。因此，当num=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“num--”操作（此后num的值为0），并且跳出同步代码块后，才能抢到锁。其他线程即使抢到锁，然而，此时num值已为0，也就无法通过if语句判断，从而无法再执行“num--”的操作了，也就不会出现0、-1、-2等情况了。