Java_多线程

最新推荐文章于 2021-08-16 18:49:34 发布

Yinglo_

最新推荐文章于 2021-08-16 18:49:34 发布

阅读量162

点赞数

本文链接：https://blog.csdn.net/Yinglo_/article/details/79517186

版权

一 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方法中，让线程运行。

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

[java]view plain copy
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方法逻辑比较简单的，否则代码看起来容易臃肿不易查看。

示例代码如下：

[java]view plain copy
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接口方式

[java]view plain copy
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的相加的值。

[java]view plain copy
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）将“单对象多线程”修改成“多对象多线程”

[java]view plain copy
  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和负数的票。

[java]view plain copy
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和负数票，这里也能体现出多线程的随机性。

解决办法：

[java]view plain copy
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.

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

[java]view plain copy
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.

实例：单例模式。

[java]view plain copy
 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 ;  
    }  
       }  

六死锁

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

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

[java]view plain copy
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.

[java]view plain copy
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锁，进行获取。

//生产者与消费者。

[java]view plain copy
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();

[java]view plain copy
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)，则可以将其设置为守护线程。

[java]view plain copy
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();  
       }  
}  