黑马程序员_java基础加强之多线程

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

多线程
多线程的概述

进程：是一个正在执行的的程序。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫做一个控制单元。
线程：进程的一个独立控制单元，线程在控制这进程的执行。一个进程中至少有个一进程。

例子：Java虚拟机启动时会有一个java.exe进程，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码在main方法中，该线程称之为主线程。

扩展：JVM启动时不止一个线程，还有负责来垃圾回收机制的线程。

创建线程
创建线程的第一种方式：继承Thread类。

步骤：

1.定义类继承Thread

2.复写Thread类中的run方法

目的：将自定义的代码存储在run方法中，让线程运行。

3.调用线程的start方法。该方法两个作用：启动线程，调用run方法。



发现运行结果每一次都不同

因为多个线程都在获取cpu的执行权。cpu执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行，（多核除外）

cpu在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行形容为在互相抢夺cpu的执行权。

这就是多线程的一个特征：随机性。谁抢到谁执行，至于执行多长，cpu说了算。

class demo
extends thread

{

public voidrun ()

{

for(int x=0;x<60;x++)

system.out.println("demo run---"+x);

}

}

class ThreadDemo

{

public static void main (string [] args)

{

demo d =
new demo(); //创建好一个线程。

d.start();//开启线程并执行该线程的run方法。

//d.run()//仅仅是对象调用方法。而线程创建了，并没有执行。并且这样还是单线程，运行结束后才会执行main。

for(int x=0;x<60;x++)

system.out.println("main"+x);

}

}

创建线程-run和start特点：

为什么要覆盖run方法呢？

由于Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

run和start的区别：
run只执行方法，而start启动线程并执行run方法。  

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

步骤：

1.定义类实现Runnable接口。

2.覆盖Runnable接口中的run方法。

3.通过Thread类建立线程对象。

4.将Runnable接口子类对象作为实参，传递给Thread类的构造方法。

5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

售票例子：

class Ticketimplements Runnable {

    //200张票
    privateintticke =
200;
    Objiect obj=new Object();

     publicvoid run() {
       while(true) {
synchronized(obj){

           if(ticket > 0)
              System.out.println(Thread.currentThread().getName()+"
"+ticket--);
   }

       }

    }

}

public
class ThreadDemo {

    public
staticvoid main(String[] args) {

        

       Ticket t = newTicket();

       Thread t1 = new Thread(t);

       Thread t2 = new Thread(t);

       Thread t3 = new Thread(t);

       Thread t4 = new Thread(t);

      

       t1.start();

       t2.start();

       t3.start();

       t4.start();

    }
}

实现方式和继承方式有什么区别呢？

如果一个类中，部分代码运行多线程，部分代码不需要实现多线程，则该类实现Runnable类，然后在继承其他类。但是如果一个类继承了Thread类，则所有代码都是多线程的。

实现方式的好处：避免单继承的局限性。在定义多线程时，建议使用多线程。        

两种方式的区别：

1.继承Thread类：线程代码存放在Thread子类的run方法中。

2.实现Runnable：线程代码存放在接口子类的run方法中。

多线程安全问题

通过分析，以上售票例子发现，打印出 0，-1，-2等错票。多线程的运行出现了安全问题。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句执行了一部分，还没有执行完，

另一个线程参与进来执行。导致共享数据的错误。

解决方法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于对线程的安全问题提供了专业的解决方式：同步代码块

同步代码块：

synchronized(对象)

{

需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中进行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
如这部分修改：

publicvoid run() {

       while(true)
{

           synchronized (new
Object()) {

              if(ticketNum
> 0) {

                  try {

                     Thread.sleep(10);

                  } catch (InterruptedException e) {

                     e.printStackTrace();

                  }

                  System.out.println(Thread.currentThread().getName()+"  
"+ticketNum--);

              }

           }

       }
    }

多线程同步的前提：

1.必须要有两个或者两个以上的线程。

2.必须是多个线程使用同一个锁。必须保证同步中只有一个线程在运行。

好处：解决多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源.

多线程的死锁
死锁：同步中嵌套同步。每个线程使用一个锁。
下面的例子，一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
两个线程同时售票。一个线程使用this锁，另一个线程使用Object对象的锁。在同步代码块中嵌套同步函数，在同步函数中嵌套同步代码块。
class Ticket
implements Runnable {

   

    public
booleanflag =true;    //标记

    Object obj =
new Object();

    private
int
ticketNum = 100;   
//100张票

   

    public
void run() {

       if(flag) {

           while(true) {

              synchronized (obj) {

                  show();

              }

           }

       }

        else {

           while(true)

              show();

       }

    }

    private
synchronized
void show() {

       synchronized (obj) {

           if(ticketNum > 0) {

              try {

                  Thread.sleep(10);

              } catch (InterruptedException e) {

                  e.printStackTrace();

              }

              System.out.println(Thread.currentThread().getName()+"
show() "+ticketNum--);

           }

       }

    }

}

public
class ThreadDemo {

    public
staticvoid main(String[] args) {

        

       Ticket t = new Ticket();

       Thread t1 = new Thread(t);

       Thread t2 = new Thread(t);

       t1.start();

       try {

           Thread.sleep(10);

       } catch (InterruptedException e) {

           e.printStackTrace();

       }

       t.flag =
false;//避免两个线程都执行同步函数（show方法）

       t2.start();

    }

}
出现死锁原因：如果第1个线程执行同步代码块，在同步代码块中又有同步函数，所以第1个线程拥有Object锁的同时又获得this锁，此时如果第2个线程执行同步函数（获取this锁），由于第1个锁已经获取this锁了，所有两个线程都等待对象释放this锁，造成死锁。