2. 程式人生 > >Java執行緒總結---第一天

Java執行緒總結---第一天

阿新 • • 發佈：2019-02-26

執行緒和程序各自有什麼區別和優劣：

  • 程序是資源分配的最小單位，執行緒是程式執行的最小單位

  • 程序有自己的獨立地址空間，每啟動一個程序，系統就會為它分配地址空間，建立資料表來維護程式碼段、堆疊段和資料段，這種操作非常昂貴。而執行緒是共享程序中的資料的，使用相同的地址空間，因此CPU切換一個執行緒的花費遠比程序要小很多，同時建立一個執行緒的開銷也比程序要小很多，執行緒的上下文切換的效能消耗要小於程序。

  • 執行緒之間的通訊更方便，同一程序下的執行緒共享全域性變數、靜態變數等資料。

  • 多程序程式更健壯，多執行緒程式只要有一個執行緒死掉，整個程序也死掉了，而一個程序死掉並不會對另外一個程序造成影響，因為程序有自己獨立的地址空間。

並行與併發

併發是沒有時間上的重疊的，兩個任務是交替執行的，由於切換的非常快，對於外界呼叫者來說相當於同一時刻多個任務一起執行了；而並行可以看到時間上是由重疊的，也就是說並行才是真正意義上的同一時刻可以有多個任務同時執行。

小程式demo

public class Demo extends Thread {
    @Override
    public void run() {
        while (true){
            System.out.println(this.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Demo demo= new Demo();
        demo.start();
    }
}

public class Demo implements Runnable {
    @Override
    public void run() {
        while (true){
            System.out.println("hello thread");
        }
    }

    public static void main(String[] args) {
        Demo demo= new Demo();
        Thread thread=new Thread(demo,"t1");
        thread.start();
    }
}

public class Demo{

    public int count = 0;


    public  void print() {

        while (true){
            System.out.println(count++);
        }
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                new Demo().print();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                new Demo().print();
            }
        }).start();
    }
}

synchronized鎖範圍

普通同步方法，鎖是當前例項物件

靜態同步方法，鎖是當前類的class物件

同步方法塊，鎖是括號裡面的物件

public class Demo{

    public synchronized void synsMethod1(){
        System.out.println("method1---");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synsMethod3();
    }
    public synchronized  void  synsMethod2(){
        System.out.println("method2---");
    }

    public synchronized  void  synsMethod3(){
        System.out.println("method3---");
    }
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod2();
            }
        }).start();
    }
}

輸出結果

method1---
method3---
method2---

再如下

public class Demo{

    public synchronized void synsMethod1(){
        System.out.println("method1---");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synsMethod3();
    }
    public synchronized static void  synsMethod2(){
        System.out.println("method2---");
    }

    public synchronized  void  synsMethod3(){
        System.out.println("method3---");
    }
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod2();
            }
        }).start();
    }
}

輸出結果（其中一種可能）

method1---
method2---
method3---

所以說靜態方法的鎖和非靜態方法的鎖是不一樣的

Synchronized鎖重入

關鍵字Synchronized擁有鎖重入的功能，也就是在使用Synchronized的時候， 當一個執行緒得到一個物件的鎖後，在該鎖裡執行程式碼的時候可以再次請求該物件的鎖 時可以再次得到該物件的鎖。

當執行緒請求一個由其它執行緒持有的物件鎖時，該執行緒會阻塞，而當執行緒請求由自己持有的物件鎖時，如果該鎖是重入鎖，請求就會成功，否則阻塞。

一個簡單的例子就是：在一個Synchronized修飾的方法或程式碼塊的內部呼叫本 類的其他Synchronized修飾的方法或程式碼塊時，是永遠可以得到鎖的。

/**
 * @program: demo
 * @description:
 * @author: lee
 * @create: 2019-02-25
 **/
public class Demo{

    public synchronized void synsMethod1(){
        System.out.println("method1---");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synsMethod2();
    }
    public synchronized void synsMethod2(){
        System.out.println("method2---");
    }
    public static void main(String[] args) {
        Demo demo=new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.synsMethod2();
            }
        }).start();
    }
}

為什麼要引入可重入鎖這種機制哪？

假如有一個執行緒T獲得了物件A的鎖，那麼該執行緒T如果在未釋放前再次請求該物件的鎖時，如果沒有可重入鎖的機制，是不會獲取到鎖的，這樣的話就會出現死鎖的情況，所以最大的作用是避免死鎖。

volatile與synchronized的

volatile關鍵字的作用就是強制從公共堆疊中取得變數的值，而不是執行緒私有的資料棧中取得變數的值。

關鍵字volatile是執行緒同步的輕量級實現，效能比synchronized要好，並且volatile只能修飾變數，而synchronized可以修飾方法，程式碼塊等。

多執行緒訪問volatile不會發生阻塞，而synchronized會發生阻塞。

volatile可以保證資料的可見性，但不可以保證原子性（不是執行緒安全的），而synchronized可以保證原子性，也可以間接保證可見性，因為他會將私有記憶體和公共記憶體中的資料做同步。

volatile解決的是變數在多個執行緒之間的可見性，而synchronized解決的是多個執行緒之間訪問資源的同步性。

ThreadLocal

ThreadLocal提供了執行緒的區域性變數，每個執行緒都可以通過set()和get()來對這個區域性變數進行操作，但不會和其他執行緒的區域性變數進行衝突，實現了執行緒的資料隔離。

簡要言之：往ThreadLocal中填充的變數屬於當前執行緒，該變數對其他執行緒而言是隔離的。

最典型的應用

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
/**
 * 採用ThreadLocal封裝Connection
 * 
 * @author Administrator
 *
 */
public class ConnectionManager {
 
	//定義ThreadLocal靜態變數，確定存取型別為Connection
	private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>();
	
	/**
	 * 得到Connection
	 * @return
	 */
	public static Connection getConnection() {
		Connection conn = connectionHolder.get();
		//如果在當前執行緒中沒有繫結相應的Connection
		if (conn == null) {
			try {
				Class.forName("oracle.jdbc.driver.OracleDriver");
				String url = "jdbc:oracle:thin:@localhost:1521:bjpowern";
				String username = "drp1";
				String password = "drp1";
				conn = DriverManager.getConnection(url, username, password);
				//將Connection設定到ThreadLocal
				connectionHolder.set(conn);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return conn;
	}
	
	/**
	 * 關閉資料庫連線方法
	 * @return
	 */
	public static void closeConnection() {
		Connection conn = connectionHolder.get();
		if (conn != null) {
			try {
				conn.close();
				//從ThreadLocal中清除Connection
				connectionHolder.remove();
			} catch (SQLException e) {
				e.printStackTrace();
			}	
		}
	}
	
	/**
	 * 關閉資料庫連線方法
	 * @return
	 */
	public static void close(Connection conn) {
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void close(Statement pstmt) {
		if (pstmt != null) {
			try {
				pstmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void close(ResultSet rs ) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 事務開啟
	 * @return
	 */
	public static void beginTransaction(Connection conn) {
		try {
			if (conn != null) {
				if (conn.getAutoCommit()) {
					conn.setAutoCommit(false); //手動提交
				}
			}
		}catch(SQLException e) {}
	}
	
	/**
	 * 事務提交
	 * @return
	 */
	public static void commitTransaction(Connection conn) {
		try {
			if (conn != null) {
				if (!conn.getAutoCommit()) {
					conn.commit();
				}
			}
		}catch(SQLException e) {}
	}
	
	/**
	 * 事務回滾
	 * @return
	 */
	public static void rollbackTransaction(Connection conn) {
		try {
			if (conn != null) {
				if (!conn.getAutoCommit()) {
					conn.rollback();
				}
			}
		}catch(SQLException e) {}
	}	
}

初始化預設值

public class ThreadlLocalDemo {

    /**
     * 初始化一個ThreadLocal物件，並且初始值設定為0
     */
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public int getNextNumber() {
        threadLocal.set(threadLocal.get() + 1);
        return threadLocal.get();
    }

    static class DemoThread extends Thread {
        ThreadlLocalDemo threadlLocalDemo = null;

        public DemoThread(ThreadlLocalDemo localDemo) {
            this.threadlLocalDemo = localDemo;
        }


        @Override
        public void run() {

            for (int i = 0; i < 5; i++) { // 每個執行緒列印 5個值
                System.out.println("Thread:" + Thread.currentThread().getName()
                        + ",threadlLocalDemo:" + threadlLocalDemo.getNextNumber());
            }

        }
    }

    public static void main(String[] args) {
        ThreadlLocalDemo threadlLocalDemo = new ThreadlLocalDemo();
        DemoThread demoThread = new DemoThread(threadlLocalDemo);
        DemoThread demoThread2 = new DemoThread(threadlLocalDemo);
        DemoThread demoThread3 = new DemoThread(threadlLocalDemo);
        DemoThread demoThread4 = new DemoThread(threadlLocalDemo);

        demoThread.start();
        demoThread2.start();
        demoThread3.start();
        demoThread4.start();

    }
}

ThreadLocal實現的原理

首先，我們來看一下ThreadLocal的set()方法，因為我們一般使用都是new完物件，就往裡邊set物件了

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

上面有個ThreadLocalMap，我們去看看這是什麼？


static class ThreadLocalMap {

        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
		
		 /**
	 * Construct a new map initially containing (firstKey, firstValue).
	 * ThreadLocalMaps are constructed lazily, so we only create
	 * one when we have at least one entry to put in it.
	 */
	 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
		 table = new Entry[INITIAL_CAPACITY];
		 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
		 table[i] = new Entry(firstKey, firstValue);
		 size = 1;
		 setThreshold(INITIAL_CAPACITY);
	 }
		//....很長
}

通過上面我們可以發現的是ThreadLocalMap是ThreadLocal的一個內部類。用Entry類來進行儲存

我們的值都是儲存到這個Map上的，key是當前ThreadLocal物件！

如果該Map不存在，則初始化一個：

void createMap(Thread t, T firstValue) {
     t.threadLocals = new ThreadLocalMap(this, firstValue);
}

如果map存在


/**
* Get the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param  t the current thread
* @return the map
*/
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}

Thread維護了ThreadLocalMap變數


/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null

從上面又可以看出，ThreadLocalMap是在ThreadLocal中使用內部類來編寫的，但物件的引用是在Thread中！ 於是我們可以總結出：Thread為每個執行緒維護了ThreadLocalMap這麼一個Map，而ThreadLocalMap的key是LocalThread物件本身，value則是要儲存的物件。

有了上面的基礎，我們看get()方法就一點都不難理解了：


public T get() {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			@SuppressWarnings("unchecked")
			T result = (T)e.value;
			return result;
		}
	}
	return setInitialValue();
}

ThreadLocal原理總結

每個Thread維護著一個ThreadLocalMap的引用

ThreadLocalMap是ThreadLocal的內部類，用Entry來進行儲存

呼叫ThreadLocal的set()方法時，實際上就是往ThreadLocalMap設定值，key是ThreadLocal物件，值是傳遞進來的物件

呼叫ThreadLocal的get()方法時，實際上就是往ThreadLocalMap獲取值，key是ThreadLocal物件

ThreadLocal本身並不儲存值，它只是作為一個key來讓執行緒從ThreadL

相關推薦

Java執行緒總結---第一天

執行緒和程序各自有什麼區別和優劣： 程序是資源分配的最小單位，執行緒是程式執行

java執行緒總結--synchronized關鍵字，原理以及相關的鎖

在多執行緒程式設計中，synchronized關鍵字非常常見，當我們需要進行“同步”操作時，我們很多時候需要該該關鍵字對程式碼塊或者方法進行鎖定。被synchronized鎖定的程式碼塊，只能同時有一條執行緒訪問該程式碼塊。 上面是很多人的認識，當然也是我之前對synchronized關鍵字的淺

JAVA執行緒總結（ 二）

繼續上篇的總結，這次我們講執行緒同步機制 執行緒同步是為了確保執行緒安全，所謂執行緒安全指的是多個執行緒對同一資源進行訪問時，有可能產生資料不一致問題，導致執行緒訪問的資源並不是安全的。如果多執行緒程式執行結果和單執行緒執行的結果是一樣的，且相關變數的值與預期值一樣，則是執行緒安全的。

Java執行緒入門第一篇

Java執行緒的狀態有6種 1、  初始(NEW)：新建立了一個執行緒物件，但還沒有呼叫start()方法。 2、  執行(RUNNABLE)：Java執行緒中將就緒（ready）和執行中（running）兩種狀態籠統的稱為“執行”。（什麼是就緒） 執行緒物件建立後，其他執行緒(比如m

JAVA執行緒總結（完結篇）

執行緒池概述 程式啟動一個新執行緒成本是比校高的,因カ它渉及到要與作業系統迸行互動而使用執行緒池可以很好的提高效能,尤其是當程式中要建立大量生存期很短的執行緒吋,更應該考慮執行緒池.執行緒池裡的毎一個執行緒程式碼結束後,井不會死亡,而是再次回到執行緒池中成為空閒

Java執行緒總結

一、Java執行緒同步原理 Java會為每個object物件分配一個monitor，當某個物件的同步方法（synchronized methods ）被多個執行緒呼叫時，該物件的monitor將負責處理這些訪問的併發獨佔要求。當一個執行緒呼叫一個物件的同步方法時，JVM會檢

Java執行緒總結（八）：併發包------讀寫鎖ReadWriteLock的簡單例子詳細理解

初次接觸ReadWriteLock類時也在網上查了很多資料，很容易瞭解到ReadWriteLock是讀寫鎖，並且讀寫鎖的機制有以下三個特點：  讀鎖---讀鎖    （不互斥）  讀鎖---寫鎖     （互斥）  寫鎖---寫鎖     （互斥）什麼意思呢？網上很多資料，

Java執行緒模型總結

1. 計算機系統 使用快取記憶體來作為記憶體與處理器之間的緩衝，將運算需要用到的資料複製到快取中，讓計算能快速進行；當運算結束後再從快取同步回記憶體之中，這樣處理器就無需等待緩慢的記憶體讀寫了。 快取一致性：多處理器系統中，因為共享同一主記憶體，當多個處理器的運算任務都設計到同一塊記憶體區域

Java執行緒學習和總結（執行緒的概念）

執行緒的概念： 多執行緒允許在程式中併發執行多個指令流，每個指令流都稱為一個執行緒，彼此間互相獨立。它和程序一樣擁有獨立的執行控制，由作業系統負責排程，區別在於執行緒沒有獨立的儲存空間，而是和所屬程序中的其它執行緒共享一個儲存空間，這使得執行緒間的通訊遠較程序簡單。 具體到java記憶體模型，

java執行緒學習總結

1.理解程式、程序、執行緒的概念 程式可以理解為靜態的程式碼 程序可以理解為執行中的程式。 執行緒可以理解為程序的進一步細分，程式的一條執行路徑 2.如何建立java程式的執行緒（重點） 方式一：繼承於Thread類   class PrintNum

【小家Java】一次Java執行緒池誤用（newFixedThreadPool）引發的線上血案和總結

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

java執行緒學習總結（一）

(宣告：並非原創，只是一個簡單總結) 一、執行緒和程序的概念：            程序：程序是處於執行過程中的程式，並且具有一定的對功能，是系統進行資源分配和排程的一個獨立單位。      

總結下java執行緒池的處理策略

執行緒池 任務提交給執行緒池之後的處理策略： 如果當前執行緒池中的執行緒數目<corePoolSize，則每來一個任務，就會建立一個執行緒去執行這個任務； 如果當前執行緒池中的執行緒數目>=corePoolSize，則每來一個任務，會嘗試將其新增到任務快取隊列當中，若

【第22天】Java執行緒基礎、併發集合

1 概述 2 生命週期（五狀態圖） 3 如何定義一個執行緒 4 控制執行緒執行的方法 1 概述        程式當中一條獨立的執行線索。Java中的主執行緒是一個J

Java執行緒池簡單總結

概述 執行緒可認為是作業系統可排程的最小的程式執行序列，一般作為程序的組成部分，同一程序中多個執行緒可共享該程序的資源（如記憶體等）。在單核處理器架構下，作業系統一般使用分時的方式實現多執行緒；在多核處理器架構下，多個執行緒能夠做到真正的在不同處理核心並行處理。

JAVA執行緒池精華總結

一. 為什麼用執行緒池（執行緒池的作用） 1. 建立/銷燬執行緒伴隨著系統開銷，過於頻繁的建立/銷燬執行緒，會很大程度上影響處理效率 例如： 記建立執行緒消耗時間T1，執行任務消耗時間T2，銷燬執行緒消耗時間T3 如果T1+T3>T2，那麼是不是說開啟一個執行

【Java執行緒】Java JVM 記憶體模型總結

Java的併發採用的是共享記憶體模型（而非訊息傳遞模型），執行緒之間共享程式的公共狀態，執行緒之間通過寫-讀記憶體中的公共狀態來隱式進行通訊。多個執行緒之間是不能直接傳遞資料互動的，它們之間的互動只能通過共享變數來實現 同步是顯式進行的。程式設計師必須顯式指定某個方法或某段

【總結】53道JAVA執行緒面試題

1) 什麼是執行緒？ 執行緒是作業系統能夠進行運算排程的最小單位，它被包含在程序之中，是程序中的實際運作單位。程式設計師可以通過它進行多處理器程式設計，你可以使用多執行緒對運算密集型任務提速。比如，如果一個執行緒完成一個任務要100毫秒，那麼用十個執行緒完成改任務只需10毫秒。Java在語言層面

java執行緒基礎方面的總結-多執行緒(一)

1:  同學,解釋一下什麼是執行緒,什麼是程序,我們為什麼要使用多執行緒   我的理解就是程序就是一段可執行的程式,而線相當於執行這段程式中一個可執行的單元     接下來我們從兩個方面解釋為什麼要使用多執行緒減少響應得到時間,我們如果使用單執行緒的話,例如某個操作很耗時間,

Java多執行緒總結之執行緒安全佇列Queue

在Java多執行緒應用中，佇列的使用率很高，多數生產消費模型的首選資料結構就是佇列。Java提供的執行緒安全的Queue可以分為阻塞佇列和非阻塞佇列，其中阻塞佇列的典型例子是BlockingQueue，非阻塞佇列的典型例子是ConcurrentLinkedQueue，在實際