黑马程序员——Java多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一 Java多线程

1.概念

进程：是一个正在执行的程序，每一个进程执行都会有一个执行顺序，该顺序是一个执行路径，或者叫控制单元，一个进程可以有多个线程。

线程：是进程的一个独立的控制单元，线程在控制着进程的执行。

线程从宏观上来说是串行执行，从微观上来说是并行执行。

2.Java中多线程

jvm在运行时会有一个java.exe进程，该程序中至少有一个线程是负责Java程序的执行。而且这个线程的运行代码存在于main代码块中。该线程称为主线程。其实jvm不止一个线程，还有一个线程，负责垃圾回收机制。

3.多线程特性

随机性；谁抢到谁执行，执行多长时间，cup说的算在没有人为控制的情况下。

二  创建线程

创建线程有两种方式：继承Thread和实现Runnable接口。

1.继承Thread类

创建步骤：

（1）定义类继承thread类。

（2）重写thread类中的run方法。

（3）调用线程的strat方法。该方法有俩个动作：启动线程，调用run方法。

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

实例：有两个卖票窗口，卖不同的票。

class ThreadDemo extends Thread{      ThreadDemo(Stringname){           super(name);      }      //覆盖run方法，      publicvoid run(){           inttick=100;           while(tick>0){                 System.out.println(Thread.currentThread().getName()+"..."+tick);                 tick--;                 }      }   }public class Test1{      publicstatic void main(String[] args){           ThreadDemot1=new ThreadDemo("老人票窗口");           ThreadDemot2=new ThreadDemo("小孩票窗口");           t1.start();           t2.start();           }}

第二种写法：使用内部匿名类

不创建类继承Thread，而是直接通过匿名内部类的特点直接在内部创建一个线程实例。该方法只能是线程中run方法逻辑比较简单的，否则代码看起来容易臃肿不易查看。

示例代码如下：

public class ThreadJCTest {     public static void createThreadByNestClass(){         Thread th= new Thread(){//匿名内部类               public void run(){                    for (int x=0;x<10;x++){                        System. err.println(Thread.currentThread().getName()+ "..." +x);                   }              }         };         th.start();    }     public static void main(String[] args) {          createThreadByNestClass();    }}

2.实现runable接口

分析步骤：

（1）定义类实现runable接口。

（2）覆盖runable接口中的run方法。

       目的: 将线程要运行的代码放在run方法中。

（3）通过thread类创建线程对象。

（4）将runable接口的子类对象作为实际参数传递给thread类的构造方法。

        目的： 自定义的run方法的所属的对象是runable接口的子类对象。所以要让线程指定哪个对象的run方法就必须明确该run方法的所属对象。

（5）调用thread类中的start的方法，开启线程并调用runable接口子类的run方法。

//实现runnable接口方式

class MyRunnable implements Runnable{       //覆盖run方法，       private  int tick=100;       publicvoid run(){              while(true){                     if(tick>0){                     System.out.println(Thread.currentThread().getName()+"..."+tick--);                     }                     elsebreak;              }       }     }public class Test1{       publicstatic void main(String[] args){              MyRunnablet=new MyRunnable();              Threadt1=new Thread(t,"小孩票窗口");              Threadt2=new Thread(t,"老人票窗口");              t1.start();              t2.start();              }}

3.两种创建方式区别

上述2种方式都可以创建线程，而且从示例代码上看，线程执行的功能是一样的，那么这三种创建方式有什么不同呢？

　　这涉及到Java中多线程的运行模式，对于Java来说，多线程在运行时，有“多对象多线程”和“单对象多线程”的区别：

       多对象多线程，程序在运行过程中创建多个线程对象，每个对象上运行一个线程。

       单对象多线程，程序在运行过程中创建一个线程对象，在其上运行多个线程。

显然，从线程同步和调度的角度来看，多对象多线程要简单一些。上述2种线程创建方式，前一个属于“多对象多线程”，后者既可以使用“多对象多线程”，也可以使用“单对象单线程”。

 

俩种继承方式和实现方式有什么区别；

实现可以继承别的类，如果继承了thread类则无法继承别的类。

继承thread：线程运行代码存放在thread子类的run方法中。

实现runable：线程运行代码存放在实现该接口的run方法中。

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

三 线程状态及切换

线程状态总的可分为五大状态：分别是创建、运行、冻结、等待/阻塞、消亡。用一个图来描述如下：

 

运行状态：经过start方法达到运行状态。

冻结状态：经过sleep(time)方法可以到达冻结状态，经过time时间后，重新回到运行状态。

在运行时，还可以经过wait()方法冻结状态。经过notity()；方法回到运行状态。

阻塞状态：具备运行资格，但没有执行权，跟运行状态互通。在冻结状态被唤醒时，不一定马上就会运行，这就是临时状态。也称为阻塞状态。

死亡状态：在运行过程中经过stop()；方法可以让线程消亡，run方法执行完后也会消亡。

状态之间的切换我们会用到下面方法：

       *Thread()或者Thread(Runnable)：构造线程。

       *Thread.start：启动线程。

       *Thread.sleep：将线程切换至休眠状态。

       *Thread.interrupt：中断线程的执行。

       *Thread.join：等待某线程结束。

       *Thread.yield：剥夺线程在CPU上的执行时间片，等待下一次调度。

       *Object.wait：将Object上所有线程锁定，直到notify方法才继续运行。

       *Object.notify：随机唤醒Object上的1个线程。

       *Object.notifyAll：唤醒Object上的所有线程。

 

四 线程的名称

线程都有自己的默认名称：thread-xxx，从0开始。

setName( )：设定线程名称；

getName( ); 获取线程名称；

thread.currentThread（）方法，和this方法作用一样。前面是通用方法。获取当前线程对象的名称；

GroupName：每个线程都会默认在一个线程组里，我们也可以显式的创建线程组，一个线程组中也可以包含子线程组，这样线程和线程组，就构成了一个树状结构。

五 线程安全问题

线程同步，大部分情况下，我们是在针对“单对象多线程”的情况进行讨论，一般会将其分成两部分，一部分是关于“共享变量”，一部分关于“执行步骤”。

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

安全问题如何确定：

（1）明确哪些代码是多线程运行代码。

（2）明确哪些是共享数据。

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

同步的前提：

（1）须要有俩个或者两个以上的线程。

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

（3）必须保证同步中只能有一个线程运行。

弊端：多个线程都需要判断锁，消耗资源。

1.控制共享变量

当我们在线程对象（Runnable）中定义了全局变量，run方法会修改该变量时，如果有多个线程同时使用该线程对象，那么就会造成全局变量的值被同时修改，造成错误。

实例：计算1到100的相加的值。

class MyRunnable implements Runnable {     int sum=0;     public void run(){          for (int x=1;x<=100;x++){               sum+=x;               try {                   Thread. sleep(50);                   }                    catch (Exception e){                         System. err.println("错误" );                   }                System. err.println(Thread.currentThread().getName()+ "..."+x);                System. err.println(Thread.currentThread().getName()+ "..."+ sum);         }          System. err.println( "线程结束" +sum );    }}public class Test1{        public static void main(String[] args) {         MyRunnable m= new MyRunnable();         Thread t= new Thread(m,"线程1");         Thread t1= new Thread(m,"线程2");         t.start();         t1.start();    }}

正确结果是5050，输出出来确实10100，这时因为俩个线程同时对sum进行操作。

如何控制线程同步

既然线程同步有上述问题，那么我们应该如何去解决呢？针对不同原因造成的同步问题，我们可以采取不同的策略。

 

我们可以采取3种方式来控制共享变量。

（1）将“单对象多线程”修改成“多对象多线程”

   

  publicclass Test1{        public static void main(String[] args) {         MyRunnable m= new MyRunnable();                MyRunnable m1= new MyRunnable();         Thread t= new Thread(m,"线程1");         Thread t1= new Thread(m1,"线程2");         t.start();         t1.start();        }}

输出结果为线程1和线程2都是5050.

（2）将“全局变量”降级为“局部变量”

　　既然是共享变量造成的问题，那么我们可以将共享变量改为“不共享”，即将其修改为局部变量。这样也可以解决问题，

（3）使用ThreadLocal机制

　　ThreadLocal是JDK引入的一种机制，它用于解决线程间共享变量，使用ThreadLocal声明的变量，即使在线程中属于全局变量，针对每个线程来讲，这个变量也是独立的。

2.控制执行步骤

安全问题原由：当多态语句操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来，导致共享数据的错误。如多窗口卖票出现负数的票和0票。

 

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

 

Java所提供的解决办法中，synchronized是一个非常重要的关键字。它的原理和数据库中事务锁的原理类似。我们在使用过程中，应该尽量缩减synchronized覆盖的范围，原因有二：

1）被它覆盖的范围是串行的，效率低；

2）容易产生死锁。

所以我们应该把需要同步的内容集中在一起，尽量不包含其他不相关的、消耗大量资源的操作

（1）同步代码块：

格式：synchronized( 对象 ){   需要被同步的代码块 }

 

对象如同锁，持有锁的对象才能在同步代码块中执行，没有持有锁的线程即使获得cpu的执行权，也进不去。

示例：模拟卖票时出现0和负数的票。

class MyRunnable implements Runnable{       //覆盖run方法，       private  int tick=100;       publicvoid run(){              while(true){                     if(tick>0){                     try{                     Thread.sleep(10);                     }                     catch(Exceptione){                            thrownew RuntimeException("error");                     }                     System.out.println(Thread.currentThread().getName()+"..."+tick--);                     elsebreak;                     }              }       }     }public class Test1{       publicstatic void main(String[] args){              MyRunnablet=new MyRunnable();              Threadt1=new Thread(t,"小孩票窗口");              Threadt2=new Thread(t,"老人票窗口");              t1.start();              t2.start();              }}

输出结果中可能会出现0和负数票，这里也能体现出多线程的随机性。

解决办法：

class MyRunnable implements Runnable{       //覆盖run方法，       private  int tick=100;       publicvoid run(){              while(true){                     //同步锁                     synchronized(this){                     if(tick>0){                         try{Thread.sleep(10); }catch(Exceptione){throw new RuntimeException("error");}                        System.out.println(Thread.currentThread().getName()+"..."+tick--);                     }                     elsebreak;                     }              }       }     }public class Test1{       publicstatic void main(String[] args){              MyRunnablet=new MyRunnable();              Threadt1=new Thread(t,"小孩票窗口");              Threadt2=new Thread(t,"老人票窗口");              t1.start();              t2.start();              }}

（2）同步函数

在线程运行的同步代码中的函数上加上synchronized.

注意，必须是线程操作共享数据的函数上加入同步函数。

class MyRunnable implements Runnable{       //覆盖run方法，       private  int tick=100;       booleanflag=true;       publicvoid run(){              while(flag){                     show();              }       }       //同步函数       publicsynchronized void show(){              if(tick>0){                         try{Thread.sleep(10); }catch(Exceptione){throw new RuntimeException("error");}                        System.out.println(Thread.currentThread().getName()+"..."+tick--);                     }                     elseflag=false;       }}public class Test1{       publicstatic void main(String[] args){              MyRunnablet=new MyRunnable();              Threadt1=new Thread(t,"小孩票窗口");              Threadt2=new Thread(t,"老人票窗口");              t1.start();              t2.start();              }}

注意：

在使用synchronized关键字时候，应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法，因为synchronized程序块占有着对象锁，你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率，也不合逻辑。

同样，在同步程序块内调用yeild方法让出CPU资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。

同步函数用的哪个锁呢？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this。所以同步函数的锁是this。

 

静态同步函数用哪个锁？

因为静态方法中不可以定义this，所有不是this对象。

静态进内存时，内存中还没有对象，但是一定有该类对应的字节码文件对象，类名.class 该对象的类型是Class.

实例：单例模式。

       

 class Single{    private static Single s =null;    private Single(){    }    public static Single getinstends(){          if(s ==null){//双重判断，减少资源消耗。//存在多线程安全问题，同步代码块，代码块对象为本类对象，也可以是s.class,防止实例化多个对象。          synchronized (s) {4//当A程序进来停止住，B程序再进来会实例化多个对象               if(s ==null){                    s= new Single();              }         }         }          return s ;    }       }

六 死锁

线程发生死锁可能性很小，即使看似可能发生死锁的代码，在运行时发生死锁的可能性也是小之又小。

同步中嵌套同步，且锁不一样时，容易发生死锁。

public class Sisuotest implements Runnable{       booleanb=true;       Sisuotest(booleanb){              this.b=b;       }       publicvoid run (){                     if(b){                            synchronized(MyLock.s1) {                            System.err.println("if--a--");                            synchronized(MyLock.s2) {                                          System.err.println("if--a--");                                   }                            }                     }                     else{                            synchronized(MyLock.s2) {                                          System.err.println("else--a--");                                          synchronized(MyLock.s1) {                                                        System.err.println("else--a--");                                                }       }                     }}       publicstatic void main(String[] args) {              Threadt=new Thread(new Sisuotest (true));              Threadt1=new Thread(new Sisuotest (false));              t.start();              t1.start();       }}class MyLock{       staticMyLock s1=new MyLock();       staticMyLock s2=new MyLock();}

七 线程间通信

就是多个线程操作同一资源，但是操作的动作不同。

示例：生产者与消费者

1.等待唤醒机制

wait(); 当前线程等待

notify(); 唤醒线程

notifyall(); 唤醒全部线程

这三个方法都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，只有同步才有锁。

 

为什么这些方法要定义到Object类中呢？

因为这些方法在操作同步中的线程时，都必须要标示他们所操作的线程持有的锁，只有同一个锁上的被等待的线程，才可以被同一锁上的notify唤醒。也就是所等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

等待的线程都放在线程池中，临时存放，当notify唤醒时唤醒的是线程池中的线程，线程池中有N多线程，那么要唤醒谁呢？通常唤醒第一个被等待的。

 

生产者与消费者例子：

当出现多个线程，例如多个生产者和多个消费者时，需要每次判断标记用while不能用if

如果用while也可能会出现全部等待的情况下，所以唤醒时需要全部唤醒用notifyall.

class Resource{       privateString name;       privateint age;       privateboolean flag=false;       publicsynchronized void set(String name,int age){              //如果有资源，需要等待，取出资源。              if(flag){                     try{wait(); }catch(Exception e){ throw new RuntimeException("等待失败"); }              }              this.name=name;              this.age=age;              flag=true;              notify();       }       publicsynchronized void out(){              //如果没有资源需要等待，存入资源。              if(!flag){                     try{wait(); }catch(Exception e){ throw new RuntimeException("等待失败"); }              }              System.out.println("name:"+name+"age"+age);              flag=false;              notify();              }}//生产者class Input implements Runnable{       privateResource r;       Input(Resourcer){              this.r=r;       }       publicvoid run(){              intx=0;              while(true){                     if(x==0){                            r.set("张三",30);                            }                     else                            r.set("李四",40);                     x=(x+1)%2;              }       }}//消费者class Output implements Runnable{       privateResource r;       Output(Resourcer){              this.r=r;       }       publicvoid run(){              while(true)                     r.out();       }}public class Test1{       publicstatic void main(String [] args){              Resourcer=new Resource();              Inputi=new Input(r);              Outputo=new Output(r);              newThread(i).start();              newThread(o).start();       }}

Jdk1.5中提供了多线程的解决方案。本方只唤醒对方的线程，不在全部唤醒。

将同步synchronized替换成显示的lock操作。

将object中的wait(),notify(),notifyall(),替换成condition对象。

改对象可以lock锁，进行获取。

//生产者与消费者。

import java.util.concurrent.locks.*;class Resource{       privateString name;       privateint count;       privateboolean flag=false;       privateLock lock=new ReentrantLock();       Conditioncondition_pro=lock.newCondition();       Conditioncondition_con=lock.newCondition();       publicvoid setProducer(String name)throws Exception{              lock.lock();//获取锁。              try{              while(flag)//判断标记              condition_pro.await();              this.name="..."+count++;              System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);              flag=true;              condition_con.signal();              }              finally{                     lock.unlock();              }       }       publicvoid getConsumer()throws Exception{              try{              lock.lock();//获取锁；              while(!flag)//判断锁标记              condition_con.await();//消费者等待；               System.out.println(Thread.currentThread().getName()+".消费."+this.name);              flag=false;              condition_pro.signal();              }              finally{                     lock.unlock();              }       }}//生产者class Producer implements Runnable{       privateResource r;       Producer(Resourcer){              this.r=r;       }       publicvoid run(){              while(true){                     try{                     r.setProducer("商品");                     }                     catch(Exceptione){                            thrownew RuntimeException("存入错误");                     }              }       }}//消费者class Consumer implements Runnable{       privateResource r;       Consumer(Resourcer){              this.r=r;       }       publicvoid run(){              while(true){                     try{                     r.getConsumer();                     }                     catch(Exceptione){                            thrownew RuntimeException("存入错误");                     }              }       }}public class Test1{       publicstatic void main(String[] args){              Resourcer=new Resource();              newThread(new Producer(r)).start();              newThread(new Consumer(r)).start();       }}

八 停止线程

stop方法已过时。

如何停止线程？

只有一种方法，让run方法结束，开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run党法结束，也就是线程结束。

特殊情况：

当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让线程从冻结状态恢复到运行状态时，这时需要对冻结状态进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread类提供了该方法interrupt();

public class StopThread implements Runnable{     boolean flag= true ;     public void changflag(){          flag= false ;    }     public synchronized   void run() {          // TODO Auto-generated method stub          while (flag ){               try {                   wait();              } catch (InterruptedException e){                    // TODO Auto-generated catch block            System. err.println(Thread.currentThread().getName()+"Exption...");                    flag= false ;              }                System. err.println(Thread.currentThread().getName()+ "run...");          }    }     public static void main(String[] args) {          // TODO Auto-generated method stub         StopThread s= new StopThread();         Thread t= new Thread(s);         Thread t1= new Thread(s);         t.start();         t1.start();          int num=0;          while (true ){          if (num++ ==60){//            s.changflag();              t.interrupt(); //中断线程t冻结状态。              t1.interrupt(); //中断线程t1冻结状态。               break ;         }          System. err.println(Thread. currentThread().getName()+num);         }          System. err.println( "over" );    }}

九 守护线程

守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。

class MyCommon extends Thread {       public void run() {                for (int i = 0; i < 5; i++){                        System.out.println("前台线程第" + i + "次执行！");                        try {                               Thread.sleep(7);                        } catch (Exception e) {                               e.printStackTrace();                        }                }       }} class MyDaemon implements Runnable {       public void run() {                for (int i = 0; i < 100;i++) {                       System.out.println("后台线程第" + i+ "次执行！");                        try {                               Thread.sleep(7);                        } catch (Exception e) {                               e.printStackTrace();                        }                }       }} public class Test1 {       public static void main(String[] args) {                Thread t1 = new MyCommon();                Thread t2 = new Thread(newMyDaemon());                t2.setDaemon(true);        //设置为守护线程                 t2.start();                t1.start();       }}

前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。

注意：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态。

十 其他方法

1.join方法；

抢夺cpu资源或者临时加入线程执行。

当A线程执行到B线程时，遇到join方法，A线程就会等待，等B线程执行完毕后A才会执行。

另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

2.线程优先级

setPriority(int newPriority)更改线程的优先级。

getPriority()获取当前线程的优先级。

每个线程都会有自己的优先级，JVM对优先级的处理方式是“抢占式”的。当JVM发现优先级高的线程时，可能会优先运行该线程；对于多个优先级相等的线程，JVM对其进行轮询处理。

Java的线程优先级从1到10，默认是5，Thread类定义了2个常量：MIN_PRIORITY NORM_PRIORITY和MAX_PRIORITY来表示最低、默认和最高优先级。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

3.yield()方法

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

因此yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

4.线程睡眠

A:线程睡眠是帮助所有线程获得运行机会的最好方法。

B:线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

C:sleep()是静态方法，只能控制当前正在运行的线程。

 

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------