2. 程式人生 > >java 多執行緒 之Thread

java 多執行緒 之Thread

阿新 • • 發佈：2019-01-07

參考部落格

Java多執行緒學習（總結很詳細！！！）

根據java 8關於thread的介紹：

有兩種方法可以建立執行緒

第一種是繼承Thread ，需要重寫Thread的run方法

class PrimeThread extends Thread {
    long minPrime;
    PrimeThread(long minPrime) {
        this.minPrime = minPrime;
    }
 
    public void run() {
        // compute primes larger than minPrime
         . . .
    }
}

 以下程式碼將建立一個執行緒並開始執行

 PrimeThread p = new PrimeThread(143);
 p.start();

 另一個方法是implements Runable 介面

class PrimeRun implements Runnable {
    long minPrime;
    PrimeRun(long minPrime) {
         this.minPrime = minPrime;
    }
 
    public void run() {
        // compute primes larger than minPrime
         . . .
    }
}
 
 PrimeRun p = new PrimeRun(143);
 new Thread(p).start();

今天就說一下Thread與Runable

public class Thread implements Runnable

//返回當前正在執行的執行緒的引用
public static native Thread currentThread();

//使當前執行緒從執行狀態（執行狀態）變為可執行態（就緒狀態），但還可能會繼續執行當前執行緒
public static native void yield();

//正在執行的執行緒進入休眠狀態（暫時停止執行）
//millis 休眠時間 毫秒 >=0
public static native void sleep(long millis) throws InterruptedException;

//指定毫秒數以及納秒數
public static void sleep(long millis, int nanos)
    throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }
//分配一個新的Thread物件
public Thread() {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }

//
 public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

//name 新執行緒的name
public Thread(String name) {
        init(null, null, name, 0);
    }



 
public class Thread1 extends Thread {
	
	
	@Override
	public void run() {
		for(int i = 0;i < 5;i++) {
			System.out.println(Thread.currentThread().getName()+": "+i);
		}
	}
	
	
}



/**
 * start()方法的呼叫後並不是立即執行多執行緒程式碼，而是使得該執行緒變為可執行態（Runnable），什麼時候執行是由作業系統決定的。
 * @author yifei.Wang
 *
 */
public class Main {

	public static void main(String[] args) {
		Thread1 mTh1 = new Thread1();
		Thread1 mTh2 = new Thread1();
		mTh1.start();
		mTh2.start();
		//mTh2.start(); 重複呼叫會出異常

	}

}
public class Thread1 implements Runnable {
	
	@Override
	public void run() {
		for(int i = 0;i < 5;i++) {
			System.out.println(Thread.currentThread().getName()+": "+i);
		}
	}
	
}

public class Main {

	public static void main(String[] args) {
		Thread1 tq = new Thread1();
		new Thread(tq).start();
		new Thread(tq).start();
	}

}

如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable介面的話，則很容易的實現資源共享。

因為有多個Thread，那麼就要new 多個 Thread 因為有共享資源，所以資源必須是static修飾的

例如

public class Thread2 extends Thread {
	
	static int m = 10;
	@Override
	public void run() {
		for(int i = 0;i < 5;i++) {
			m--;
			System.out.println(Thread.currentThread().getName()+": "+i+": "+m);
		}
	}
}


public class Main {

	public static void main(String[] args) {
		Thread2 t1 = new Thread2();
		Thread2 t2 = new Thread2();
		Thread2 t3 = new Thread2();
		Thread2 t4 = new Thread2();
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

但是 如果使用Runnable

public class Thread1 implements Runnable {
	
	private int m = 10;
	@Override
	public void run() {
		for(int i = 0;i < 5;i++) {
			m--;
			System.out.println(Thread.currentThread().getName()+": "+i+": "+m);
		}
	}
	
}

public class Main2 {

	public static void main(String[] args) {
		Thread1 thread1 = new Thread1();
		new Thread(thread1).start();
		new Thread(thread1).start();
		new Thread(thread1).start();
		new Thread(thread1).start();
	}

}

則不需要設定 靜態變量了，因為我們一直用一個Thread1  沒有new 多個Thread1 ，也可以說，如果我們new 多個Thread1 ，那麼使用private就不行了

發現 Thread也實現了Runnable介面，Runnable接口裡只有一個run方法

啟動執行緒的時候就會呼叫run方法

public interface Runnable {

    public abstract void run();

}

java中執行緒是有優先順序的

 /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

//設定優先順序
public final void setPriority(int newPriority) {
        ThreadGroup g;
        checkAccess();
        if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
            throw new IllegalArgumentException();
        }
        if((g = getThreadGroup()) != null) {
            if (newPriority > g.getMaxPriority()) {
                newPriority = g.getMaxPriority();
            }
            setPriority0(priority = newPriority);
        }
    }

// 獲取優先順序
 public final int getPriority() {
        return priority;
    }

但在上邊的例子中，發現，主執行緒一直比子執行緒結束的早。Java中主執行緒結束後子執行緒繼續執行，但C中會報錯

所以用到了join方法

//等待執行緒die，只有這個執行緒結束後才能繼續執行後面的程式
public final void join() throws InterruptedException {
        join(0);
    }

//設定時間，若為0的話，永遠等待
public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }


 public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        join(millis);
    }
public class Main2 {

	public static void main(String[] args) {
		Thread1 thread1 = new Thread1();
		Thread t1 = new Thread(thread1);
		Thread t2 = new Thread(thread1);
		t1.start();
		t2.start();
		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(Thread.currentThread().getName()+"主執行緒結束");
	}

}

這樣的話，主執行緒必須等這兩個執行緒全結束才能結束

yield() 暫停當前正在執行的物件，並執行其他執行緒，只是讓當前執行緒轉換為可執行狀態，以允許具有相同優先順序的執行緒獲得執行機會，但無法保證yield達到讓步的目的。

sleep() 使當前執行緒進入停滯狀態，所以執行sleep的執行緒在指定時間內肯定不會被執行

sleep()方法允許較低有優先順序的執行緒獲取執行機會，但yield()不會

Obj.wait()，與Obj.notify()必須要與synchronized(Obj)一起使用，也就是wait,與notify是針對已經獲取了Obj鎖進行操作，從語法角度來說就是Obj.wait(),Obj.notify必須在synchronized(Obj){...}語句塊內。從功能上來說wait就是說執行緒在獲取物件鎖後，主動釋放物件鎖，同時本執行緒休眠。直到有其它執行緒呼叫物件的notify()喚醒該執行緒，才能繼續獲取物件鎖，並繼續執行。相應的notify()就是對物件鎖的喚醒操作。但有一點需要注意的是notify()呼叫後，並不是馬上就釋放物件鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖後，JVM會在wait()物件鎖的執行緒中隨機選取一執行緒，賦予其物件鎖，喚醒執行緒，繼續執行。這樣就提供了線上程間同步、喚醒的操作。Thread.sleep()與Object.wait()二者都可以暫停當前執行緒，釋放CPU控制權，主要的區別在於Object.wait()在釋放CPU同時，釋放了物件鎖的控制。

但是  synchronized 到底是什麼？

相關推薦

Java多執行緒之Thread中的六種狀態說明

Java多執行緒之Thread中的六種狀態說明 六種狀態 執行緒流程圖 檢視JVM中對應的執行緒 六種狀態 在Java的可以通過Thead.getState()獲取當前執行緒的狀態，返回的資料型別是在Thread.

java 多執行緒 之Thread

參考部落格 Java多執行緒學習（總結很詳細！！！） 根據java 8關於thread的介紹： 有兩種方法可以建立執行緒 第一種是繼承Thread ，需要重寫Thread的run方法 class PrimeThread extends Thread { long minP

Java多執行緒之 Thread VS Runnable 【帶案例】

為此，我們舉個例子，假設有火車站有三個視窗，在賣火車票，總共只有5張票。每一個執行緒相當於一個視窗，分別售票 <strong>package com.thread; class my

Java多執行緒之Thread

執行緒的定義 是作業系統進行運算排程的最小單位。它被包含在程序之中，是程序中的實際運作單位。 一個執行緒指的是程序中一個單一順序的控制流，一個程序中可以並行多個執行緒，每條執行緒並行執行不同的任務。 每個執行緒都有一個優先順序，預設是5（1~10，值越大，優

java 多執行緒之利用Thread類建立執行緒（Day02）

前言：在一個程式中，如果一次只完成一件事情，很容易實現，但現實生活中很多事情都是同時進行的，所以在java中為了模擬這種狀態，引入了執行緒機制，簡單的說，當程式同時完成很多事情時，就是所謂的多執行緒。 實現執行緒的兩種方式：一是通過繼承Thread類來建立執行緒，另一種方法

JAVA多執行緒之Runnable和Thread比較

在我們開發的過程中常常會碰到多執行緒的問題，對於多執行緒的實現方式主要有兩種：實現Runnable介面、繼承Thread類。對於這兩種多執行緒的實現方式也是有著一些差異。既然實現了多執行緒那必然離不開管理這些執行緒，當問題比簡單時一個或者幾個執行緒就OK了，也涉

Java多執行緒之"事件分發執行緒"----Event Dispatch Thread

當執行GUI小程式(Applet)或應用程式(Application)時,main()方法中的程式碼會建立一個GUI並設定事件控制代碼.當呼叫Frame,Dialog,Window的setVisible(true)或瀏覽器顯示Applet時,我們就是在和GUI互動.   問題

Java多執行緒之join()方法

概要 本章，會對Thread中join()方法進行介紹。涉及到的內容包括： 1. join()介紹 2. join()原始碼分析(基於JDK1.7.0_40) 3. join()示例 來源：http://www.cnblogs.com/skywang12345/p/34792

白話理解java多執行緒之join()方法

join字面意思是加入,我理解為插隊. 舉例:媽媽在炒菜,發現沒喲醬油了,讓兒子去打醬油,兒子打完醬油,媽媽炒完菜,全家一起吃 package cn.yh.thread01; /** * * 打醬油的例子 */ public class Demo03 { public stat

細說Java 多執行緒之記憶體可見性

前言： 討論學習Java中的記憶體可見性、Java記憶體模型、指令重排序、as-if-serial語義等多執行緒中偏向底層的一些知識，以及synchronized和volatile實現記憶體可見性的原理和方法。 1、可見性介紹 可見性：一個執行緒對共用變數值的修改，能夠及時地被其他執行緒

java多執行緒之 執行緒協作

也是網上看的一道題目：關於假如有Thread1、Thread2、Thread3、Thread4四條執行緒分別統計C、D、E、F四個盤的大小，所有執行緒都統計完畢交給Thread5執行緒去做彙總，應當如何實現？ 蒐集整理了網上朋友提供的方法，主要有： 1. 多執行緒都是Thread或

java多執行緒之鎖機制二

網上看到一個題目，題目是這樣：Java多執行緒，啟動四個執行緒，兩個執行加一，另外兩個執行減一。 針對該問題寫了一個程式，測試通過，如下： class Sync { static int count = 0; public void add() {

java多執行緒之鎖機制一

網上看了一篇關於java synchronized關鍵字使用的很好的文章，現將其簡要總結一下，加深理解。 先總結兩個規則： synchronized鎖住的是括號裡的物件，而不是程式碼。對於非static的synchronized方法，鎖的就是物件本身也就是this。 多個執行緒

java多執行緒之Phaser

java多執行緒技術提供了Phaser工具類，Phaser表示“階段器”，用來解決控制多個執行緒分階段共同完成任務的情景問題。其作用相比CountDownLatch和CyclicBarrier更加靈活，例如有這樣的一個題目：5個學生一起參加考試，一共有三道題，要求所有學生到齊才能開始考試，全部同學都

Java多執行緒之——ThreadLocal

ThreadLocal是什麼：每一個ThreadLocal能夠放一個執行緒級別的變數，也就是說，每一個執行緒有獨自的變數，互不干擾。以此達到執行緒安全的目的，並且一定會安全。 實現原理： 要了解實現原理，我們先看set方法 public void set(T value) { T

java多執行緒之Lock--顯式鎖

Lock與Synchronized簡介 Synchornized相信大家用的已經比較熟悉了，這裡我就不介紹它的用法了 Synchronized被稱為同步鎖或者是隱式鎖，隱式鎖與顯式鎖區別在於，隱式鎖的獲取和釋放都需要出現在一個塊結構中，而且是有順序的，獲取鎖的順序和釋放鎖的順序必須相反，就是說，

Java多執行緒之Executor框架

在前面的這篇文章中介紹了執行緒池的相關知識，現在我們來看一下跟執行緒池相關的框架--Executor。 一.什麼是Executor 1.Executor框架的兩級排程模型 在HotSpot VM的執行緒模型中，Java執行緒（java.lang.Thread）被一對一對映為本地作業系統執

java多執行緒之Executor

程式 程序：執行的程式 執行緒：程序中負責程式執行的執行單元，一個程序至少包括一個執行緒。 單執行緒：一個程序一個執行緒 多執行緒：一個程序多個執行緒   多執行緒是為了更好的利用CPU，提高程式執行的速度。 實現方式：繼承Thread類、實現Runnabl

java多執行緒之（二）鎖

一，鎖 在物件的建立時java會為每個object物件分配一個monitor（ 監視器或者監視鎖），當某個物件的同步方法（synchronized methods ）被多個執行緒呼叫時，該物件的monitor將負責處理這些訪問的併發獨佔要求。 當一個執行緒呼叫一個物件的同步方法時（sy

Java多執行緒之鎖優化策略

轉載 http://www.cnblogs.com/ygj0930/p/6561264.html 編碼過程中可採取的鎖優化的思路有以下幾種： 1：減少鎖持有時間 例如：對一個方法加鎖，不如對方法中需要同步的幾行程式碼加鎖； 2：減小鎖粒度 例如：