Java多线程

一 线程的创建：
1.相关概念：          
     1）进程：是一个正在执行中的程序，每个进程执行都有一个执行顺序。该顺序是一个执行路径，或叫一个控制单元。
     2）线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。
     3）主线程：Java虚拟机启动的时候会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。（其实更细节的说明jvm,jvm启动不止一个线程，还有负责垃圾回收机制的线程）。
2.创建线程：
    如何在自定义的代码中，自定义一个线程？通过查找api，java已经提供这类事物的描述。就是thread类。同时可以了解到自定义线程有两种方式。
   第一种方式：
步骤：1) 定义类继承Thread类
         2) 目的是复写Thread类中的run方法。（目的是让自定义的代码存储在run方法让线程运行）
          3) 通过创建Thread类的子类对象，创建线程对象
          4) 调用线程的start方法，该方法有两个作用：启动线程和调用执行run方法。
   线程状态：
     1) 新建：start()
        2) 运行：具备执行资格，同时具备执行权；
     3) 冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
     4) 临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
     5) 消亡：stop()
示例代码如下：

public class ThreadDemo1 extends Thread {private int count = 10;@Override// 在run方法中定义任务public void run() {while (count > 0) {System.out.println(this.getName() + "(" + count + ")");count--;}}public static void main(String[] args) {new ThreadDemo1().start();new ThreadDemo1().start();// 由于start方法迅速返回，所以main线程可以执行其他的操作,此时有两个独立的线程在并发运行System.out.println("新年倒计时：");}}

打印结果：

新年倒计时：Thread-0(10)Thread-0(9)Thread-0(8)Thread-0(7)Thread-0(6)Thread-0(5)Thread-0(4)Thread-0(3)Thread-0(2)Thread-0(1)Thread-1(10)Thread-1(9)Thread-1(8)Thread-1(7)Thread-1(6)Thread-1(5)Thread-1(4)Thread-1(3)Thread-1(2)Thread-1(1)

第二种方式：
  步骤：1）定义类实现Runnable接口中
        2）覆盖Runnable接口中的run方法， 将线程要运行的代码存放在该run方法中。
        3）通过thread类建立线程对象。
        4）将Runnable接口的子类对象传递给Thread的构造函数。为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
        5) 调用Thread类的start方法开启的线程并调用Runnable接口子类的run方法。
        问：为什么要将Rinnable接口的子类对象作为实际参数传递给Thread的构造方法？
        答：直接创建Runnable对象，并不是创建线程对象。因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。
所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。因为，自定义的run方法所属的对象时Runnable接口的子类对象，所以要让子线程去指定对象的run方法，就必须明确run方法所属的对象。
示例代码如下：

public class ThreadDemo2 implements Runnable {private int count = 10;@Override// 在run方法中定义要实现的代码public void run() {while (count > 0) {System.out.println(Thread.currentThread().getName() + "(" + count+ ")");count--;}}public static void main(String[] args) {ThreadDemo2 tt = new ThreadDemo2();new Thread(tt).start();new Thread(tt).start();System.out.println("新年倒计时：");}}

方式二打印结果：

新年倒计时：Thread-0(10)Thread-1(10)Thread-0(9)Thread-1(8)Thread-0(7)Thread-1(6)Thread-1(4)Thread-0(5)Thread-1(3)Thread-0(2)Thread-1(1)

3. 两种方式的比较：
   问：同样是建立两个线程为什么，打印的结果却不相同？
    答：实现Runnable接口方式创建线程可以共享同一个目标对象（TreadDemo1 tt=new TreadDemo1();），实现了多个相同线程处理同一份资源，如代码中的成员变量count。
   问：实现方式和继承方式创建线程有什么区别？
   答：继承方式线程代码代码存放在thread子类run方法中。实现方式线程代码存放在Runnable接口的子类的run方法中。实现方式的好处：避免了单继承的局限性，在定义线程时，建议使用实现方式。
   问：为什么要覆盖run方法?
   答：Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该代码存储功能就是run方法。
二 多线程的特性：
        多个线程都在获取cpu的执行权，cpu执行到谁，就运行谁。明确一点的是，在某一个时刻，只能有一个程序在运行（多核除外）。我们可以形象把多线程的运行行为在互相抢夺cpu执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长是由cpu决定的。
         多线程关系图：

三 线程安全：

1 多线程安全问题的原因：

    发现一个线程在执行多条语句时，一个线程对多条语句只执行一部分，并运算同一个数据时，在执行过程中，还没有执行完，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

   涉及到两个因素：

  1）多个线程在操作共享数据。

  2）有多条语句对共享数据进行运算。

  原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

 解决办法：

    对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。如何进行多句操作共享数据代码的封装呢？Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。

Synchronized(//对象){<span style="font-family: SimSun;font-size:10px;">//</span><span style="font-family: SimSun;font-size:10px; color: rgb(192, 0, 0);"> </span><span style="font-family: SimSun;font-size:10px;">任意对象都可以。这个对象就是锁。</span>//需要被同步的代码块}//在同步代码块中，对象如同锁。将所有的线程可以在同步执行。没有持有锁的线程即使获取cpu的执行权，也不能执行代码块里的代码，因为没有获取到锁。

2.同步的前提：

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

   2)必须是多个线程使用同一个锁。

 3.同步的好处与弊端：

   好处：解决了多线程的安全问题

   弊端：多个线程需要判断锁，较为耗费时间。

4. 如何找到在多线程中出现的问题：

    1)明确哪些代码是多线程代码

    2)明确共享数据

    3)明确多线程运行代码中哪些语句是操作共享数据的

5.关于同步代码还有另外一种写法那就是同步方法：            

public synchronized void method() {   //要被同步的代码}

   问：同步方法用的是哪一个锁呢？

   答：方法需要被对象调用。那么函数都有一个所属的对象引用。就是this,所以同步函数使用的锁是this。

public static synchronized void method(){//需要被同步的代码}

   问：如果是同步函数被静态修饰后，使用的锁是什么呢？

   答：通过验证，发现不是this。因为静态方法中不可以定义this。静态进入内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。类名.class 该类对象的类型是类名.class，该对象的类型是class。静态的同步                                方法，使用的锁是该方法所在的类的字节码文件对像：类名.class。
 6.线程安全的经典案例：单例中的懒汉式的线程安全

  懒汉式在多线程访问时会产生安全隐患，懒汉式的一般写法如下代码：             

class Single {private static Single s = null;private Single() {}public static Single getInstance() {if (s == null)//--->有可能多个线程都执行到这个地方s = new Single();return s;}}

   注释所标记的地方可能会出现线程安全问题，因为当多个线程同时访问到getInstance()方法时，可能会有多个线程运行至注释处，最后会导致new出多个Single类出来，产生线程安全问题。 为了避免这种情况发生，在写懒汉式的单例时最好在getInstance()可能会产生线程安全的代码加上锁，代码如下：

class Single {private static Single s = null;private Single() {}public static Single getInstance() {synchronized (Single.class) {if (s == null)s = new Single();return s;}}}

四 线程通信

  关于线程通信的几个重要方法：wait();notify();notifyAll();  这些方法都使用在同步中，因为要持这监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

提示：wait和sleep区别： 分析这两个方法，从执行权和锁上来分析：

  wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。

  sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

  wait：线程会释放执行权，而且线程会释放锁。

  sleep：线程会释放执行权，但不释放锁。

通过查看api文档发现上述的几个方法都有在Object类中定义。

问：为什么这些操作线程的方法要定义Object类中呢。

答：因为这些方法在操作同步中线程时，都必须标示它们锁操作线程只有的锁。只有一个锁上的被等待线程，可以被同一个锁上的notify所唤醒。不可以对不同锁上的线程进行唤醒。也就是说等待和唤醒是同一个锁。而锁可以是任意的对象，所以可以被任意的对象调用的方法定义Object类中。

线程通信的经典案例生产者消费者：                  

class ProuducerConsumer {public static void main(String args[]) {SyncStack ss = new SyncStack();Producer producer = new Producer(ss);Consumer consumer = new Consumer(ss);new Thread(producer).start();new Thread(consumer).start();}}class SyncStack {int index = 0;public synchronized void push() {/* * if (index == 5) { try { this.wait(); } catch (InterruptedException e) * { e.printStackTrace(); } }// if应该要用while代替 * 因为i如果catch到exception会跳出if语句往下执行 而while语句会再次判断 index ==6 */while (index == 5) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}index++;this.notify();}// 而这段程序的加 放前后区别不大 因为i有后面的pop叫醒 他。。。。。。。public synchronized void pop() {/* index--; */if (index == 0) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}this.notify();index--;}}// 先减再执行一段程序和先执行一段程序再减 有很大不同的。。。。。。先减的话会导致程序不能正常结束// 因为先减的话会导致最后消费第19个Cake时线程会进入wait状态，而生产者已经生产完19个cake从而没有线程去notify它class Cake {int id = 0;Cake(int id) {this.id = id;}}class Producer implements Runnable {SyncStack ss = null;Producer(SyncStack ss) {this.ss = ss;}public void run() {for (int i = 1; i < 20; i++) {ss.push();System.out.println("生产了Cake" + i);}}}class Consumer implements Runnable {SyncStack ss = null;Consumer(SyncStack ss) {this.ss = ss;}public void run() {try {Thread.sleep(10000);// 开始生产者可能还没开始生产，先等十秒让生产者生产Cake} catch (Exception e) {}for (int i = 1; i < 20; i++) {ss.pop();System.out.println("消费了Cake" + i);}}}

    该代码实现的功能是：当生产者生产剩余的产品为五件时会通过wait()方法使线程等待停止生产，并通过notify方法通知正在等待的消费者(如果消费者在等待的话)，当消费剩余的产品为0件时消费者停止消费等待生产者生产完产品后通知其继续消费。程序运用到线程同知的好处是，消费者能根据生产者生产的产品数量去消费，而不会导致其过度盲目的消费从而参数线程安全问题。

JDK1.5中提供另外多线程的升级解决方案：

将同步Synchronized替换成现实Lock操作，将Object中的wait(),notify,notifyAll替换了Condition对象。该对象可以Lock锁，进行获取对象。该生产者消费者示例中，实现了本方只唤醒对方的操作。

class ProducerConsumerDemo{   public static void main(String args){    Resource r=new Resource();    Producer pro=new Producer();    Consumer con=new Consumer();     Thread  t1=new Thread(pro);      Thread  t2=new Thread(pro);     Thread  t3=new Thread(con);      Thread  t4=new Thread(con);      t1.start();      t1.start();      t1.start();      t1.start();                     }    } class Resource{  private String name;  private int count=1;  private  boolean flag=false;  private Lock lock=new RecentrantLock();  pricate Condition condition_pro=lock.newCondition();   pricate Condition condition_con=lock.newCondition();   public void set(String name)throws InterruptException{   lock.lock();    try{     while(flag)       condition_pro.await();     this.name=name+"--"+conunt++;     System.out.print(Thread.currentThread().getName()+"...生产者..."+this.name);     flag=true;     condition_con.signal();       }finaly{           lock.unlock();              }       }  }    public void out()throws InterruptException{lock.lock();    try{     while(!flag)       condition_con.await();     System.out.print(Thread.currentThread().getName()+"...消费者..."+this.name);     flag=false;     condition_pro.signal();       }finaly{           lock.unlock();              }       }     }class Producer implements Runnable{    private Resource res;    Producer(Resource){        this.res=res;   }    public void run(){     while(true){      res.set("+商品+");     }   }}}class Consumer implements Runnable{    private Resource res;    Consumer(Resource){        this.res=res;   }    public void run(){     while(true){      res.out();     }   }}

五 Thread类中一其他的方法：
终止线程的方法：
      有三种方法可以使终止线程。
       1.使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 
     2.使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。 
     3.使用interrupt方法中断线程。  
   1.使用退出标志终止线程：
         当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。 

public class ThreadFlag extends Thread {public volatile boolean exit = false;public void run() {while (!exit);}public static void main(String[] args) throws Exception {ThreadFlag thread = new ThreadFlag();thread.start();sleep(5000); // 主线程延迟5秒thread.exit = true; // 终止线程threadthread.join();System.out.println("线程退出!");}}

    上面代码中定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值。
     2. 使用stop方法终止线程：
   使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程： thread.stop(); 虽然使用上面的代码可以终止线程，但使用stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，因此，并不推荐使用stop方法来终止线程。 
     3. 使用interrupt方法终止线程： 
     使用interrupt方法来终端线程可分为两种情况： 
     1）线程处于阻塞状态，如使用了sleep方法。 
     2）使用while（！isInterrupted（））{……}来判断线程是否被中断。 
   在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。

public class ThreadInterrupt extends Thread {     public void run()     {         try         {             sleep(50000);  // 延迟50秒         }         catch (InterruptedException e)         {             System.out.println(e.getMessage());         }     }     public static void main(String[] args) throws Exception     {         Thread thread = new ThreadInterrupt();         thread.start();         System.out.println("在50秒之内按任意键中断线程!");         System.in.read();         thread.interrupt();         thread.join();// 当线程A执行到了B线程的join()方法时，A线程就会等待。等B线程执行完A才会执行。join可以用来临时加入线程执行。        System.out.println("线程已经退出");     } } 

上面代码的运行结果如下： 

在50秒之内按任意键中断线程!     sleep interrupted     线程已经退出

    在调用interrupt方法后， sleep方法抛出异常，然后输出错误信息：sleep interrupted. 
    注意：在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted（），一个是非静态的方法isInterrupted（），这两个方法的区别是interrupted用来判断当前线是否被中断，而isInterrupted可以用来判断其他线程是否被中断。因此，while （！isInterrupted（））也可以换成while （！Thread.interrupted（））。 
   join方法:

   当线程A执行到了B线程的join()方法时，A线程就会等待。等B线程执行完A才会执行。join可以用来临时加入线程执行。