黑马程序员_多线程

 1、进程和线程：
 进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
 线程：进程内部的一条执行路径线索或者一个控制单元。
 两者的区别：
  一个进程至少有一个线程
  进程在执行过程中拥有独立的内存单元，而多个线程共享内存；

2、什么叫多线程？

一个进程中有多个线程，称为多线程。

3、多线程的好处和弊端：

好处：解决了多部分同时运行的问题，提高效率；

弊端：线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。

4、实现多线程的方法：
 实现多线程可以通过继承Thread类和实现Runnable接口。
 (1)、继承Thread
     定义一个类继承Thread类
     覆盖Thread类中的public void run()方法，将线程的任务代码封装到run方法中。
     直接创建Threadde子类对象创建线程；
     调用start()方法开启线程并调用线程的任务run方法
     //另外可以通过Thread的getName()获取线程的名称。

代码体现：
   public class ThreadDemo extends Thread
   {
    public void run()
    {
     //code
    }
   }

   public class ThreadDemoTest
   {
    public static void main(String[] args)
    {
     ThreadDemo td1 = new ThreadDemo(); 
     ThreadDemo td2 = new ThreadDemo();

     td1.start();
     td2.start();
    }
   }

 (2)、实现Runnable接口；
  定义一个类，实现Runnable接口；
  覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；
  通过Thread类创建线程对象，将Runnabl接口的子类对象作为Thread类的构造函数的参数进行传递
                       （原因：线程的任务都封装在Runnable接口子类对象的run方法中。
           所以要在线程对象创建时就必须明确要运行的任务）。
  调用线程对象的start()方法开启线程。

public class RunnableDemo implements Runnable
   {
    public void run()
    {
     //code
    }
   }

   public class RunnableDemoTest
   {
    public static void main(String[] args)
    {
     RunnableDemo rd = new RunnableDemo();

     Thread t1 = new Thread(rd);
     Thread t2 = new Thread(rd);

     t1.start();
     t2.start();
    }
   }
 
 两种方法区别：
  (1)实现Runnable接口避免了继承的局限性
  (2)继承Thread类线程代码存放在Thread子类的run方法中
     实现Runnable接口线程代码存放在接口的子类的run方法中；
     在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现

5、  线程的几种状态：
 (1)新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个时候，
       只是对象线程对象开辟了内存空间和初始化数据。        
(2) 就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。
       在这个状态的线程对象，具有执行资格，没有执行权。
(3) 运行：当线程对象获取到了CPU的资源。
       在这个状态的线程对象，具有执行资格，也具有执行权。
 (4)阻塞：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行权和执行资格。
      (冻结)  当然，他们可以回到运行状态。只不过，不是直接回到。
       而是先回到就绪状态。
 (5)死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。 

6、多线程安全问题：
 (1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于随机性导致一个线程对多条语句
         执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，此时就导致共享数据发生错误。
  比如买票例子中打印重票和错票的情况。
 (2)解决方法:对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来。

7、死锁
 两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

8、多线程间通讯：
 多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同.
 如生产者消费者问题,一边生产商品,一边消费商品
 又比如有一堆煤，一辆车拉煤进来，一辆车拉煤出去

 

class Worker{
 String name;
 String sex;
 boolean flag=false;
}
class Input implements Runnable{
 private Worker w;
 Input(){}
 Input(Worker w){
  this.w=w;
 }
 
 public void run(){
  int x=0;
  while(true){
   synchronized(w){
    if(w.flag){
     try {
      w.wait();
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
    if(x%2==0){
     w.name="maik";
     w.sex="men";
    }
    else{
     w.name="露丝";
     w.sex="女的女的女的女的";
    }
    x+=1; 
    w.flag=true;
    w.notify();
   } 
   
  }
 }
}

class Output implements Runnable{
 private Worker w;
 Output(){}
 Output(Worker w){
  this.w=w;
 }
 
 public void run(){
  while(true){
   synchronized(w){
    if(!w.flag)
     try {
      w.wait();
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    System.out.println(Thread.currentThread().getName()+"::"+w.name+"::"+w.sex);
    w.flag=false;
    w.notify();
   }
  }
 }
}
public class InputOutputDemo1 {
 public static void main(String[] args) {
  Worker w= new Worker();
  
  Input in=new Input(w);
  Output out=new Output(w);
  
  Thread t1=new Thread(in);
  Thread t2=new Thread(out);
  
  t1.start();
  t2.start();
 }
}

9、停止线程：stop方法已经过时，如何停止线程？
 停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？
  开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。
  特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。
  
  为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；
  当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态