JAVA多線程

wdzgege 發(fā)布于2019-08-14 12:11 / 1164人閱讀

摘要：引起線程之間執(zhí)行順序的是競爭條件。只有資源共享才會(huì)有線程安全的問題線程資源同步和線程之間的同步。對(duì)于方法或者代碼塊，當(dāng)出現(xiàn)異常時(shí)，會(huì)自動(dòng)釋放當(dāng)前線程占用的鎖，因此不會(huì)由于異常導(dǎo)致出現(xiàn)死鎖現(xiàn)象。執(zhí)行器執(zhí)行器是實(shí)現(xiàn)的線程池。

package com.test;

public class MyThread  extends   Thread{
    @Override
    public void run() {
        System.out.println("新的線程開始運(yùn)行");
    }
    public static void main(String[] args) {
        System.out.println("main的主線程");
        new  MyThread().start();
        //start方法調(diào)用以后，那么此時(shí)CPU有可能先執(zhí)行新的線程。也有可能繼續(xù)執(zhí)行原來的線程(執(zhí)行后續(xù)的代碼)
        System.out.println("main的主線程");
    }
}

public class MyThread  extends   Thread{
    @Override
    public void run() {
        System.out.println("新的線程開始運(yùn)行");
    }
    public static void main(String[] args) {
        
         System.out.println("main的主線程");
         Thread  t=    new  MyThread();
         System.out.println(t.getState());
         t.start();
         System.out.println(t.getState());
            try {
            Thread.sleep(5000);
            } catch (InterruptedException e) {
            e.printStackTrace();
            }
        System.out.println(t.getState());
        t.start();  //只有線程狀態(tài)是NEW才可以調(diào)用start方法。
    }
}

引起線程之間執(zhí)行順序的是競爭條件。

package com.spring;

public class MyThread  extends   Thread{
    public  int  count=0;
    @Override
    public void run() {
          count++;
        
    }
    
    public  void   countAdd(){
        
        this.count++;
    }
    public static void main(String[] args) {
        
        
        System.out.println("main的主線程");
        MyThread  t=    new  MyThread();
        t.setPriority(MAX_PRIORITY);
       t.start();
       
       t.countAdd();
      System.out.println(t.count);
      System.out.println(t.count);
      System.out.println(t.count);
      System.out.println(t.count);
      System.out.println(t.count);
    }

}

并非只有靜態(tài)變量才會(huì)有線程不安全，如上，如果count++不是原子操作的話，成員變量依然會(huì)不安全。因?yàn)橘Y源是共享的，而run方法卻在不同的線程中運(yùn)行。

線程在真正執(zhí)行的時(shí)候完全不是按照一條語句一條語句的執(zhí)行。
比如：
if(count>0)
只要資源不共享，斷續(xù)著的切換執(zhí)行根本沒有問題。只有資源共享才會(huì)有線程安全的問題
線程資源同步和線程之間的同步。
線程之間的同步就是比如A執(zhí)行完之后要執(zhí)行B，然后執(zhí)行C。就是在線程之間有順序的執(zhí)行。

等待與阻塞：
等待是等待另外一個(gè)線程出現(xiàn)結(jié)果，或者另一個(gè)線程的調(diào)度，阻塞是沒有獲得鎖
守護(hù)線程：
與守護(hù)進(jìn)程是有區(qū)別的。當(dāng)沒有工作線程的時(shí)候，就停止了。
wait方法等待并釋放這個(gè)鎖。
對(duì)于synchronized方法或者synchronized代碼塊，當(dāng)出現(xiàn)異常時(shí)，JVM會(huì)自動(dòng)釋放當(dāng)前線程占用的鎖，因此不會(huì)由于異常導(dǎo)致出現(xiàn)死鎖現(xiàn)象。
有時(shí)候你會(huì)看到有所謂的類鎖和對(duì)象鎖的說法。
`假設(shè)我有一個(gè)類ClassA，其中有一個(gè)方法synchronized methodA()，那么當(dāng)這個(gè)方法被調(diào)用的時(shí)候你獲得就是對(duì)象鎖，但是要注意，如果這個(gè)類有兩個(gè)實(shí)例，比如：
ClassA a = new ClassA();
ClassA b = new ClassA();
那么如果你在a這對(duì)象上調(diào)用了methodA，不會(huì)影響b這個(gè)對(duì)象，也就是說對(duì)于b這個(gè)對(duì)象，他也可以調(diào)用methodA，因?yàn)檫@是兩對(duì)象，所以說對(duì)象鎖是針對(duì)對(duì)象的。`
在這里主要討論一個(gè)使用上的問題，當(dāng)我們使用sychronized鎖住某個(gè)對(duì)象時(shí)，我們鎖住的是這個(gè)引用本身，還是內(nèi)存（堆）中的這個(gè)對(duì)象本身。對(duì)這個(gè)問題的一個(gè)延伸是，當(dāng)我們?cè)趕ychronized作用區(qū)域內(nèi)，為這個(gè)引用附一個(gè)新值的時(shí)候，sychronized是否還有效？
先給出結(jié)論，sychronized鎖住的是內(nèi)存（堆）中的對(duì)象，當(dāng)引用被附上新值的時(shí)候，則相當(dāng)于舊對(duì)象的鎖被釋放。這里不做理論討論，只是用程序進(jìn)行驗(yàn)證。
http://www.cnblogs.com/shipengzhi/articles/2223100.html
static synchronized 鎖住的是整個(gè)類。會(huì)影響到所有的實(shí)例。

執(zhí)行器

執(zhí)行器是Java實(shí)現(xiàn)的線程池。

package com.ex;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class Server {
    
    private   ThreadPoolExecutor  executor;
  
    public  ThreadPoolExecutor getExecutor(){
        return  this.executor;
    }
    
    
    public  Server(){
        
//        executor=(ThreadPoolExecutor) Executors.newCachedThreadPool();// cache線程池在真正有任務(wù)的時(shí)候才初始化，隨著任務(wù)變化而變化
        executor=(ThreadPoolExecutor) Executors.newFixedThreadPool(10);//固定任務(wù)的線程池
        System.out.println("總共線程池------------------------"+executor.getPoolSize());
        System.out.println("活動(dòng)的線程池?cái)?shù)量---------------------"+executor.getActiveCount());
    }
    
    public  void  excuteTask(Task  task){
          executor.execute(task);
          System.out.println("一共得線程池"+executor.getPoolSize());
            System.out.println("活動(dòng)的線程池?cái)?shù)量，即正在處理任務(wù)的線程數(shù)量"+executor.getActiveCount());
    }

    public static void main(String[] args) {
        Server  server=new Server();
        for(int i=0;i<100;i++){
            Task  task=new Task("線程id"+i);
            server.excuteTask(task);
        }
        //主線程不斷詢問線程組是否執(zhí)行完畢
        while(true){
            
            if(server.getExecutor().getCompletedTaskCount()==100){
                System.out.println("總共線程池------------------------"+server.getExecutor().getPoolSize());
                System.out.println("活動(dòng)的線程池?cái)?shù)量---------------------"+server.getExecutor().getActiveCount());
                server.getExecutor().shutdown();
                break;
            }
        }
        
    }

}


package com.ex;

import java.util.Date;

public class Task  implements  Runnable{
    
    private  String  name;
    private  Date  date;
    
    public  Task(String name){
        this.date=new Date();
        this.name=name;

    }
    

    @Override
    public void run() {
    
        try {
            System.out.println(this.name+"----開始執(zhí)行任務(wù)");
            Thread.sleep((long) (Math.random()*1000));
            System.out.println(this.name+"----結(jié)束執(zhí)行任務(wù)");
        } catch (InterruptedException e) {
            
            e.printStackTrace();
        }
        
    }

}

線程的內(nèi)存模型

對(duì)于公共變量或者資源，線程會(huì)復(fù)制一份到屬于自己的線程棧，操作以后再放回公共資。在復(fù)制的過程中間，如果有其他線程修改了資源，那么復(fù)制的就不是最新的。這就是所謂的內(nèi)存可見性問題。同步了當(dāng)然不會(huì)存在這樣的問題，因?yàn)橥粋€(gè)時(shí)刻，另外一個(gè)線程必讀等待另一個(gè)線程讀寫完畢。

/**
 *===============================================================
 * @CopyRight:    北京逸生活技術(shù)服務(wù)有限公司技術(shù)部
 * @author:       xujianxing
 * @date:        2016年3月16日
 * @version:      1.0.0
 *===============================================================
 * 修訂日期                                                         修訂人                                                    描述
 */


package syncdemo;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

/**
 * TODO 
 * 
TODO
 * @author xujinaxing
 * @date 2016年3月16日
 * @see 
 * @since   
 * @modified TODO
 */
public class ThreadUnSafe  extends  Thread{
    public static   int  flag=0;
    public static  List  list=new ArrayList();
    
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        flag++;
//添加的時(shí)候必須同步。也就是說保證list是內(nèi)存可見的。
        synchronized (list) {
        
            list.add(flag);
        }
        System.out.println(flag);
    }
    
    
    public static void main(String[] args) {
        for(int i=0;i<10000;i++){
            new ThreadUnSafe().start();
        }
        
        try {
            Thread.currentThread().sleep(15000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        int size=new HashSet(ThreadUnSafe.list).size();
        System.out.println("size"+size);
    }
    
}

打印的值是9991.說明了線程之間由于存取不及時(shí)。導(dǎo)致set的size小于1000.

/**
 *===============================================================
 * @CopyRight:    北京逸生活技術(shù)服務(wù)有限公司技術(shù)部
 * @author:       xujianxing
 * @date:        2016年3月16日
 * @version:      1.0.0
 *===============================================================
 * 修訂日期                                                         修訂人                                                    描述
 */


package syncdemo;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * TODO 
 * 
TODO
 * @author xujinaxing
 * @date 2016年3月16日
 * @see 
 * @since   
 * @modified TODO
 */
public class ThreadSafe  extends  Thread{
    public static   AtomicInteger  flag=new AtomicInteger(0);
    public static  List  list=new ArrayList();
    
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
        int i=flag.incrementAndGet();
        synchronized (list) {
            
            list.add(i);
        }
        
        System.out.println(flag.get());
    }
    
    
    public static void main(String[] args) {
        for(int i=0;i<20000;i++){
            new ThreadSafe().start();
        }
        
        try {
            Thread.currentThread().sleep(15000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        int size=new HashSet(ThreadSafe.list).size();
        System.out.println("size"+size);
    }
    
}

上面的這個(gè)代碼是線程安全的。性能高，是李利用硬件提供的原子操作。