zoukankan      html  css  js  c++  java

  • Java中多线程原理详解

      Java是少数的集中支持多线程的语言之一，大多数的语言智能运行单独的一个程序块，无法同时运行不同的多个程序块，Java的多线程机制弥补了这个缺憾，它可以让不同的程序块一起运行，这样可以让程序运行更加顺畅，同时也达到了多任务处理的目的。

    　　一、线程和进程的概念

    　　现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

    　　进程是程序的一个动态执行过程，是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在 Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。

    　　二、Java中线程的实现

    　　在Java中想实现多线程有两种手段，一种是集成Thread类，另一种就是实现Runnable接口。下面看继承自Thread类线程的创建原理。

    　　首先定义一个线程类，该类必须继承自Thread类，同时必须明确的覆写run()方法，如： 

    1. class MyThread extends Thread{
    3. 　　public void run(){ //覆写Thread类中的run方法此方法是线程中
    4. 　　线程主体; 
    5. 　　}
    6. ｝

    然后定义一个主类，实例化线程类的对象，发动启动线程的命令，如： 

    1. public class ThreadText{
    3. 　　public stataic void main(String args[]){
    5. 　　MyThread m1=new MyThread();//实例化对象
    7. 　　m1.start();//启动多线程
    9. 　　}
    10. }


    实现Runnable接口，首先定义一个线程类继承自Runnable接口，如： 

    1. class MyThread implements Runnable{
    3. 　　public void run(){ //覆写Runnable接口中的run方法
    5. 　　线程主体;
    7. 　　}
    8. ｝

    然后定义一个主类，实例化线程类的对象，发动启动线程的命令，如： 

    1. public class ThreadText{
    3. 　　public stataic void main(String args[]){
    5. 　　MyThread m1=new MyThread();//实例化Runnable子类对象
    7. 　　Thread t1=new Thread(m1);//实例化Thread类对象
    9. 　　t1.start();//启动多线程
    11. 　　}
    12. }


          三、线程的几种状态

    　　在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

    　　第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

    　　第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

    　　第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

    　　第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

    　　第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

    多线程安全问题的解决方案：

    首先我们得明白两个概念：同步 和 互斥；

    同步——这是线程 or  进程之间的 合作关系。对多个线程在执行次序上进行协调，以使并发的各个线程能更好的利共享资源，相互合作。多个线程之间，一个线程需要等待另一个线程执行完毕后才能继续执行。 如：下文中，当一个线程拿到锁没有释放之前另一个线程不能执行，只能是等待上个线程 释放了锁之后才能执行。

    互斥——这是线程 or  进程之间的 竞争关系。在生产者消费者的例子中，当有生产者在写的时候，消费者就不能读，他们在竞争 缓冲区。

    只要 保证一个线程在执行多条操作共享数据的语句时，其他线程不能参与运算即可。

    当该线程都执行完后，其他线程才可以执行这些语句。

    Java为我们提供了具体的解决方案——同步代码块。

    synchronized（对象）{ // 对象可以是 任意的对象

    //需要被同步的代码；

    }

    在上个例子中加入synchronized 后，代码如下：

    [java] view plain copy
     
     print?
    1. package chapter1502;  
    2.   
    3. public class Ticket1 implements Runnable{  
    4.     private int tickets = 100;  
    5.       
    6.     private Object obj = new Object();  
    7.     //线程任务  
    8.     public void run(){  
    9.         while(true){  
    10.             synchronized(obj){ //加锁  
    11.                 if(tickets>0){  
    12.                     try {  
    13.                         Thread.sleep(10);  
    14.                     } catch (InterruptedException e) {  
    15.                         // TODO Auto-generated catch block  
    16.                         e.printStackTrace();  
    17.                     }  
    18.                     System.out.println(Thread.currentThread().getName() + "    " + tickets--);  
    19.                 }             
    20.             }  
    21.         }  
    22.     }  
    23. }  

    至此，就解决了 上篇所提及的 线程安全问题！

    下面介绍三个问题：同步的原理，同步的好处,弊端 ，同步的前提

    同步的原理：其实就是将需要同步的代码进行封装，并在该代码上加了一个锁。

    同步的好处，弊端：

    好处：使多线程处于能够安全的运行。

    弊端：在加了多线程之后，多个线程在对锁申请使用权的时候，会使CPU不断的切换，，这样做，会引起性能的降低。

    同步的前提：

    1. 必须要保证在同步中有多个线程。      因为同步中只有一个线程该同步是没有意义的。

    2. 必须要保证多个线程在同步中使用的是同一个锁。这是才称为 多个线程被同步了！

    关于同步的前提，请看下例代码：

    [java] view plain copy
     
     print?
    1. package chapter1502;  
    2.   
    3. public class Ticket1 implements Runnable{  
    4.     private int tickets = 100;  
    5.       
    6.     //线程任务  
    7.     public void run(){  
    8.         Object obj = new Object();  
    9.         while(true){  
    10.             synchronized(obj){ //加锁  
    11.                 if(tickets>0){  
    12.                     try {  
    13.                         Thread.sleep(10);  
    14.                     } catch (InterruptedException e) {  
    15.                         // TODO Auto-generated catch block  
    16.                         e.printStackTrace();  
    17.                     }  
    18.                     System.out.println(Thread.currentThread().getName() + "    " + tickets--);  
    19.                 }             
    20.             }  
    21.         }  
    22.     }  
    23. }  
    [java] view plain copy
     
     print?
    1. public class SaleTicket2 {  
    2.   
    3.     public static void main(String[] args) {  
    4.         //任务对象  
    5.         Ticket1 t1 = new Ticket1();  
    6.         //线程对象  
    7.         Thread td1 = new Thread(t1);  
    8.         Thread td2 = new Thread(t1);  
    9.         Thread td3 = new Thread(t1);  
    10.         Thread td4 = new Thread(t1);  
    11.           
    12.         //开启线程  
    13.         td1.start();  
    14.         td2.start();  
    15.         td3.start();  
    16.         td4.start();  
    17.     }  
    18. }  




    运行结果为：

    运行后发现，即使加了同步 ，加了锁，然而问题依旧，这是为什么呢？

    在主函数中：

    //任务对象
    Ticket1 t1 = new Ticket1();
    //线程对象
    Thread td1 = new Thread(t1);
    Thread td2 = new Thread(t1);
    Thread td3 = new Thread(t1);
    Thread td4 = new Thread(t1);

    //开启线程
    td1.start();
    td2.start();
    td3.start();
    td4.start();

    当我们在主函数中，创建了线程对象后，注意，每个run()方法中，都有一个锁，因为他们自己用的自己的锁，所以 同步就相当于没加，所以会再次出现这样的问题，故而，当我们在为同步加锁的时候，一定得保证，加的锁是同一把锁。

    同步函数：函数本身没有同步性，当我们为他加上 synchronized标记后，他也就具备了同步性。

    上述代码经过修改后：

    [java] view plain copy
     
     print?
    1. class Ticket implements Runnable  
    2. {  
    3.     private int num = 100;  
    4.     private Object obj = new Object();  
    5.     public  void run()  
    6.     {  
    7.         while(true)  
    8.         {  
    9.             show();  
    10.         }  
    11.     }  
    12.     //同步函数  
    13.     public synchronized void show()  
    14.     {  
    15.         if(num>0)  
    16.         {  
    17.             try{Thread.sleep(10);}catch(InterruptedException e){}  
    18.             System.out.println(Thread.currentThread().getName()+".....sale....."+num--);  
    19.         }  
    20.     }  
    21. }  
    22. class TicketDemo3   
    23. {  
    24.     public static void main(String[] args)   
    25.     {  
    26.         Ticket t = new Ticket();  
    27.           
    28.         //创建线程对象。  
    29.           
    30.         Thread t1 = new Thread(t);  
    31.         Thread t2 = new Thread(t);  
    32.         Thread t3 = new Thread(t);  
    33.         Thread t4 = new Thread(t);  
    34.   
    35.         t1.start();  
    36.         t2.start();  
    37.         t3.start();  
    38.         t4.start();  
    39.   
    40.     }  
    41. }  

    那么，同样是同步，同步函数和同步代码块的区别：

    1. 同步函数比同步代码块 写法简单。

    2. 同步函数使用的锁是 this . 同步代码块使用的是 任意指定的对象。

    下面主要介绍一下，锁——同步代码块，同步函数，静态同步函数使用的锁：

    1. 同步代码块使用的锁是：任意的对象；

    2. 同步函数使用的锁是： this , this代表当前对象的引用。

    3. 静态——当一个类被加载进内存以后，在我们还没有创建对象的时候，已经有对象了Xx.class。

    静态随着类的加载而加载，这时内存中存储的对象至少有一个  就是该类字节码文件对象。

    这个对象的表示方式： 类名.class 

    [java] view plain copy
     
     print?
    1. class StaticLockDemo   
    2. {  
    3.     public static void main(String[] args)   
    4.     {  
    5.         Ticket t = new Ticket();  
    6.           
    7.         //创建线程对象。  
    8.           
    9.         Thread t1 = new Thread(t);  
    10.         Thread t2 = new Thread(t);  
    11.   
    12.         t1.start();  
    13.         try{Thread.sleep(10);}catch(InterruptedException e){}  
    14.         //在开启了t1后，将标记置为false。  
    15.         t.setFlag();  
    16.   
    17.         t2.start();  
    18.   
    19.   
    20.     }  
    21. }  
    22.   
    23. class Ticket implements Runnable  
    24. {  
    25.     private static  int num = 200;  
    26.     private boolean flag = true;  
    27.     public  void run()  
    28.     {  
    29.         if(flag)//为true就执行同步代码块。  
    30.             while(true)  
    31.             {  
    32.                 synchronized(Ticket.class)  
    33.                 {  
    34.                     if(num>0)  
    35.                     {  
    36.                         try{Thread.sleep(10);}catch(InterruptedException e){}  
    37.                         System.out.println(Thread.currentThread().getName()+".....code.........."+num--);  
    38.                     }  
    39.                 }  
    40.             }  
    41.         else//为false就执行同步函数。   
    42.             while(true)  
    43.             {  
    44.                 show();  
    45.             }  
    46.     }  
    47.     /* 
    48.     将标记改为false。 
    49.     */  
    50.     public void setFlag()  
    51.     {  
    52.         flag = false;  
    53.     }  
    54.   
    55.     public static synchronized void show()  
    56.     {  
    57.         if(num>0)  
    58.         {  
    59.             try{Thread.sleep(10);}catch(InterruptedException e){}  
    60.             System.out.println(Thread.currentThread().getName()+"............func....."+num--);  
    61.         }  
    62.     }  
    63. }  
    64.   
    65. class StaticLockDemo   
    66. {  
    67.     public static void main(String[] args)   
    68.     {  
    69.         Ticket t = new Ticket();  
    70.           
    71.         //创建线程对象。  
    72.           
    73.         Thread t1 = new Thread(t);  
    74.         Thread t2 = new Thread(t);  
    75.   
    76.         t1.start();  
    77.         try{Thread.sleep(10);}catch(InterruptedException e){}  
    78.         //在开启了t1后，将标记置为false。  
    79.         t.setFlag();  
    80.   
    81.         t2.start();  
    82.   
    83.     }  
    84. }  
    85. 死锁：

      1. 指多个进程or 线程在运行过程中因争夺资源而造成的一种僵局，当线程 处于 这种僵态是，若无外力作用，他们将无法再向前推进。

        最常见的死锁情况，同步的嵌套：

        同步中还有同步，两个同步用的不是一个锁。

         我们应当，尽量避免同步嵌套的情况。

        如下所示：

        [java] view plain copy
         
         print?
        1. public class Clock {  
        2.     public static Clock locka = new Clock();  
        3.     public static Clock lockb = new Clock();  
        4. }  
        5.   
        6. public class DeadLock implements Runnable {  
        7.     private boolean flag;  
        8.       
        9.     public DeadLock(boolean flag){  
        10.         this.flag = flag;  
        11.     }  
        12.       
        13.     @Override  
        14.     public void run() {  
        15.         if(flag){  
        16.             while(true){  
        17.                 synchronized(Clock.locka){  
        18.                     System.out.println(".................if locka");  
        19.                     synchronized(Clock.lockb){  
        20.                         System.out.println(".................if lockb");  
        21.                     }  
        22.                 }  
        23.             }  
        24.         }  
        25.         else{  
        26.             while(true){  
        27.                 synchronized(Clock.lockb){  
        28.                     System.out.println("-------------------------else lockb");  
        29.                     synchronized(Clock.locka){  
        30.                         System.out.println("----------------------else locka");  
        31.                     }  
        32.                 }  
        33.             }  
        34.         }  
        35.   
        36.     }     
        37. }  
        38.   
        39. public class DeadLockTest {  
        40.   
        41.     public static void main(String[] args) {  
        42.   
        43.         DeadLock d1 = new DeadLock(true);  
        44.         DeadLock d2 = new DeadLock(false);  
        45.           
        46.         Thread t1 = new Thread(d1);  
        47.         Thread t2 = new Thread(d2);  
        48.           
        49.         t1.start();  
        50.         t2.start();  
        51.           
        52.     }  
        53. }  

        上例中，当先线程1 拿到 Clock.locka , 线程2 拿到 Clock.lockb， 但 此时，线程1 需要 Clock.lockb 来继续运行，线程2 需要 Clock.locka 来继续运行，他们互不想让，就造成了死锁的状况。
  • 相关阅读:
    这仅仅是一份工作
    和老总之间的对话
    假设满足怎样的条件，就不去编程
    那都是别人的架构
    程序员狂想曲
    学点经济学知识（三）
    一起来看 HTML 5.2 中新的原生元素 <dialog>
    动态配置页面 之 组件系统
    初识JavaScript EventLoop
    webpack+vue-cli+ElementUI+vue-resource 前端开发
  • 原文地址：https://www.cnblogs.com/wlming/p/5465771.html
Copyright © 2011-2022 走看看