2. 程式人生 > >線程基礎知識(三)

線程基礎知識(三)

阿新 • • 發佈：2018-06-03
thrown 但是 runnable take 停止 reader RR min tcp

wait、notify、notifyAll

wait、sleep、yield區別？

sleep 讓出cpu使用權但是不會釋放鎖。

public class Test {
public static void main(String[] args) {
    Object obj=new Object();
    ThreadOne one=new ThreadOne(obj);
    ThreadTwo two=new ThreadTwo(obj);
    one.start();
    two.start();
}
}

class ThreadOne extends Thread{
private Object obj;
public ThreadOne(Object obj){
    this.obj=obj;
}
@Override
public void run(){
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName());
        for (int i =0;i<5;i++) {
            System.out.println("  "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
}

class ThreadTwo extends Thread{
private Object obj;
public ThreadTwo(Object obj){
    this.obj=obj;
}
@Override
public void run(){
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName());
        for (int i =0;i<5;i++) {
            System.out.println("  "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
}

技術分享圖片

wait 只能在同步方法或方法塊中調用(即需要獲取對象的鎖),wait會讓出cpu使用和對象鎖

當線程呈wait()狀態是,調用線程對象的interrupt()方法會出現InterruptedException異常。

新手的坑

public class Mistake {
public static void main(String[] args) {
    Object object=new Object();
    MyThreadThree threadThree=new MyThreadThree(object);
    threadThree.start();
}
}

class MyThreadThree extends Thread{
private Object object;
public MyThreadThree(Object object){
    this.object=object;
}

@Override
public void run(){
    synchronized (object){
        for (int i=1;i<5;i++){
            try {
                wait();//坑點
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
}

技術分享圖片

坑點：wait() 需要調用鎖對象.wait() 上面代碼的wait()是線程對象的wait 所以拋出IllegalMonitorStateException，它是RuntimeException的一個子類不需要try-catch進行捕捉異常。

object.wait();//將wait()改為object.wait()就正確了

notify、notifyAll 也需要在同步方法或方法塊中調用(即需要獲取對象的鎖) 調用notify或notifyAll後並不會立即釋放鎖需要將程序執行完即退出synchronized代碼塊後。

notify和notifyAll的區別就是notify喚醒一個wait的線程使其的狀態變為Runnable(可運行)狀態,notifyAll是喚醒所有wait的線程

public class Test {
public static void main(String[] args) {
    Service service=new Service();
    ThreadOne one=new ThreadOne(service);
    ThreadTwo two=new ThreadTwo(service);
    one.start();
    two.start();
}
}

class Service{
private volatile boolean flag =true;

public boolean getFlag(){
    return flag;
}
public void setFlag(boolean flag){
    this.flag=flag;
}
}


class ThreadOne extends Thread{
private Service service;
public ThreadOne(Service service){
    this.service=service;
}
@Override
public void run(){
    synchronized (service) {
        while (true){
            if(service.getFlag()==true){
                try {
                    System.out.println("堵塞了One");
                    service.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                System.out.println(Thread.currentThread().getName()+"One");
                service.setFlag(true);
                service.notifyAll();
            }
        }
    }
}
}

class ThreadTwo extends Thread{
private Service service;
public ThreadTwo(Service service){
    this.service=service;
}
@Override
public void run(){
    synchronized (service) {
        while (true){
            if(service.getFlag()==false){
                try {
                    System.out.println("堵塞了 Two");
                    service.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                System.out.println(Thread.currentThread().getName()+"Two");
                service.setFlag(false);
                service.notifyAll();
            }
        }
    }
}
}

技術分享圖片

yield 會讓出cpu使用，但是不會釋放對象鎖。

public class TestYield {
public static void main(String[] args) {
    Object object=new Object();
    YieldThread yieldThread=new YieldThread(object);
    yieldThread.start();
    YieldThread yieldThreadTwo=new YieldThread(object);
    yieldThreadTwo.start();
}
}

class YieldThread extends Thread{
private Object object;
public YieldThread(Object object){
    this.object=object;
}
@Override
public void run(){
    synchronized (object) {
        for (int i = 1; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "   " + i);
            Thread.yield();
        }
    }
}
}

技術分享圖片

public class TestYield {
public static void main(String[] args) {
    YieldThread yieldThread = new YieldThread();
    yieldThread.start();
    YieldThread yieldThreadTwo = new YieldThread();
    yieldThreadTwo.start();
}
}

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

}
}

技術分享圖片

總結

  1. wait 讓出cpu使用讓出對象鎖
  2. sleep、yield 讓出cpu使用但是不讓出對象鎖
  3. wait、notify、notifyAll 只能在同步方法或方法塊中調用(即需要獲取對象的鎖)不然會拋出IllegalMonitorStateException

技術分享圖片

notify、notifyAll

先看看一個生產者多個消費者

public class TestCP {
public static void main(String[] args) {
    List<String> storeHouse = new ArrayList<>(0);
    Consumer consumer = new Consumer(storeHouse);
    Producer producer = new Producer(storeHouse);
    for (int i = 0; i < 1; i++) {
        new ProducerThread(producer).start();
    }

    for (int i = 0; i < 20; i++) {
        new ConsumerThread(consumer).start();
    }

}
}

class Consumer {
//廠庫
private List<String> storeHouse;

public Consumer(List<String> storeHouse) {
    this.storeHouse = storeHouse;
}

//消費
public void consume() {
    synchronized (storeHouse) {
        while (storeHouse.size() == 0) {
            try {
                System.out.println("沒有蛋糕了.....");
                storeHouse.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消費第一個
        storeHouse.remove(0);
        storeHouse.notify();
    }
}
}

class ConsumerThread extends Thread {
private Consumer consumer;

public ConsumerThread(Consumer consumer) {
    this.consumer = consumer;
}

@Override
public void run() {
    while (true) {
        consumer.consume();
    }
}
}

class Producer {
//廠庫
private List<String> storeHouse;

public Producer(List<String> storeHouse) {
    this.storeHouse = storeHouse;
}

//生產
public void produce() {
    synchronized (storeHouse) {
        //當廠庫裏面蛋糕數據到10就就停止生產
        while (storeHouse.size() == 10) {
            try {
                System.out.println("蛋糕有10塊了");
                storeHouse.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //生產
        storeHouse.add("蛋糕");
        storeHouse.notify();
    }
}
}

class ProducerThread extends Thread {
private Producer producer;

public ProducerThread(Producer producer) {
    this.producer = producer;
}

@Override
public void run() {
    while (true) {
        producer.produce();
    }
}
}

技術分享圖片

堵塞了..... why？？？

  1. 因為有20個消費者蛋糕數量只有10個，比如當有15個消費者等待
  2. 當生產者生產的蛋糕數量到達10個時，wait
  3. 還有5個消費者消費notify喚醒的是等待的消費者，當消費完10個蛋糕後notify還是消費者那麽這樣，所有的消費者都進入wait狀態而生產者也是wait狀態所以堵塞了。

將notify改為notifyAll後就可以正確的執行。、

storeHouse.notifyAll();

建議使用notifyAll

線程間通信：管道

一個線程發數據到輸出管道,另一個線程從輸入管道中讀取數據。

字節流

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {
public static void main(String[] args) {
    try {
        WriteData writeData = new WriteData();
        ReadData readData = new ReadData();
        PipedInputStream inputStream = new PipedInputStream();
        PipedOutputStream outputStream = new PipedOutputStream();
        //inputStream.connect(outputStream)
        outputStream.connect(inputStream);
        ThreadRead threadRead = new ThreadRead(readData,inputStream);
        threadRead.start();
        Thread.sleep(2000);
        ThreadWrite threadWrite=new ThreadWrite(writeData,outputStream);
        threadWrite.start();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

class WriteData {
public void writeMethod(PipedOutputStream out) {
    try {
        System.out.println("write :");
        for (int i = 0; i < 300; i++) {
            String outData = "" + (i + 1);
            out.write(outData.getBytes());
            System.out.print(outData);
        }
        System.out.println();
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

class ThreadWrite extends Thread {
private WriteData write;
private PipedOutputStream out;

public ThreadWrite(WriteData write, PipedOutputStream out) {
    this.write = write;
    this.out = out;
}

@Override
public void run() {
    write.writeMethod(out);
}
}


class ReadData {
public void readMethod(PipedInputStream input) {
    try {
        System.out.println("read :");
        byte[] byteArray = new byte[20];
        int readLength = input.read(byteArray);
        while (readLength != -1) {
            String newData = new String(byteArray, 0, readLength);
            System.out.print(newData);
            readLength = input.read(byteArray);
        }
        System.out.println();
        input.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

class ThreadRead extends Thread {
private ReadData read;
private PipedInputStream input;

public ThreadRead(ReadData read, PipedInputStream input) {
    this.read = read;
    this.input = input;
}

@Override
public void run() {
    read.readMethod(input);
}
}

inputStream.connect(outputStream)或outputStream.connect(inputStream)使兩個Stream之間產生通信鏈接

字符流

import java.io.*;
public class Run {
public static void main(String[] args) {
    try {
        WriteData writeData = new WriteData();
        ReadData readData = new ReadData();
        PipedReader reader = new PipedReader();
        PipedWriter writer = new PipedWriter();
        //writer.connect(reader);
        reader.connect(writer);
        ThreadRead threadRead = new ThreadRead(readData,reader);
        threadRead.start();
        Thread.sleep(2000);
        ThreadWrite threadWrite=new ThreadWrite(writeData,writer);
        threadWrite.start();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

class WriteData {
public void writeMethod(PipedWriter out) {
    try {
        System.out.println("write :");
        for (int i = 0; i < 300; i++) {
            String outData = "" + (i + 1);
            out.write(outData);
            System.out.print(outData);
        }
        System.out.println();
        out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

class ThreadWrite extends Thread {
private WriteData write;
private PipedWriter out;

public ThreadWrite(WriteData write, PipedWriter out) {
    this.write = write;
    this.out = out;
}

@Override
public void run() {
    write.writeMethod(out);
}
}


class ReadData {
public void readMethod(PipedReader input) {
    try {
        System.out.println("read :");
        char[] byteArray = new char[20];
        int readLength = input.read(byteArray);
        while (readLength != -1) {
            String newData = new String(byteArray, 0, readLength);
            System.out.print(newData);
            readLength = input.read(byteArray);
        }
        System.out.println();
        input.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

class ThreadRead extends Thread {
private ReadData read;
private PipedReader input;

public ThreadRead(ReadData read, PipedReader input) {
    this.read = read;
    this.input = input;
}

@Override
public void run() {
    read.readMethod(input);
}
}

join

如果現在有兩個線程一個線程想等另外一個線程運行結束後再運行那麽就可以使用join。

public class TestJoin {
public static void main(String[] args) {
    MyThreadJoin join=new MyThreadJoin();
    join.start();
    try {
        join.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()+" 我在等他結束後運行！！！");
}
}

class MyThreadJoin extends Thread{
@Override
public void run(){
    System.out.println("sleep..........");
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

技術分享圖片

join源碼使用wait()方法實現————也就說join會讓出cpu使用和對象鎖

/**
 * Waits at most {@code millis} milliseconds for this thread to
 * die. A timeout of {@code 0} means to wait forever.
 *
 * <p> This implementation uses a loop of {@code this.wait} calls
 * conditioned on {@code this.isAlive}. As a thread terminates the
 * {@code this.notifyAll} method is invoked. It is recommended that
 * applications not use {@code wait}, {@code notify}, or
 * {@code notifyAll} on {@code Thread} instances.
 *
 * @param  millis
 *         the time to wait in milliseconds
 *
 * @throws  IllegalArgumentException
 *          if the value of {@code millis} is negative
 *
 * @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
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;
        }
    }
}

join讓出對象鎖

public class TestJoin {
public static void main(String[] args) {
    ThreadB b=new ThreadB();
    ThreadA a=new ThreadA(b);
    a.start();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    ThreadC c=new ThreadC(b);
    c.start();
}
}

class ThreadA extends Thread{
private ThreadB threadB;
public ThreadA(ThreadB threadB){
    this.threadB=threadB;
}

@Override
public void  run(){
    try{
        synchronized (threadB){
            threadB.start();
            Thread.sleep(6000);
        }
    }catch (InterruptedException e){
        e.printStackTrace();
    }
}
}

class ThreadB extends Thread{
@Override
public void run(){
    try {
        System.out.println("ThreadB run begin time" + System.currentTimeMillis());
        Thread.sleep(5000);
        System.out.println("ThreadB run End time"+System.currentTimeMillis());
    }catch (InterruptedException e){
        e.printStackTrace();
    }
}
public synchronized void bService(){
    System.out.println("bService time"+System.currentTimeMillis());
}
}

class ThreadC extends Thread{
private ThreadB threadB;
public ThreadC(ThreadB threadB){
    this.threadB=threadB;
}

@Override
public void run(){
    threadB.bService();
}
}

技術分享圖片

將ThreadA的run()方法改為

 threadB.join();
//Thread.sleep(6000);

技術分享圖片

Java多線程編程核心技術

如果有什麽錯誤歡迎指出來，感謝感謝！才學疏淺望諒解。

線程基礎知識(三)

相關推薦

線程基礎知識(三)

thrown 但是 runnable take 停止 reader RR min tcp wait、notify、notifyAll wait、sleep、yield區別？ sleep 讓出cpu使用權但是不會釋放鎖。 public class Test { public

多線程基礎知識（二）

必須 否則 closed form 自己 back play sender 重點 線程池 因為每次創建線程、銷毀線程都比較消耗 cpu 資源，因此可以通過線程池進行優化。線程池是一組已經創建好的線程，隨用隨取，用完了不是銷毀線程，然後放到線程池中，供其他人用。 用線程池之

線程基礎知識

sync 可執行 垃圾回收器 tar 棧和堆 object 中一 聲明 退出 首先了解一下JVM、棧和堆1棧：JVM中一個線程一個棧內存，棧內存是獨立的，棧中儲存局部變量，所以局部變量的內存不共享，不會存在線程問題。2堆：JVM中只有一個堆，堆內存是多線程共享的，堆內存中儲

線程基礎知識(一)

讀後感 應用 rup IE osi 很好 state lee IT 線程基礎知識(一) 看了Java多線程編程核心技術第一章,算是讀後感吧感覺自己基礎並不是很好。 並發和並行 並發：你在吃飯突然來了一個電話，然後你去接電話，接完電話再吃飯。 並行：你在吃飯突然來了一個電

JAVA多線程基礎學習三：volatile關鍵字

編譯 一定的 true AD throws 行操作 執行效率 操作 分享圖片 Java的volatile關鍵字在JDK源碼中經常出現，但是對它的認識只是停留在共享變量上，今天來談談volatile關鍵字。 volatile，從字面上說是易變的、不穩定的，事實上，也確實如此

多線程基礎知識簡介

一段 cond add sleep star 一、基本概念 運行 多線程基礎 技術 一、基本概念：程序、進程、線程 程序（program）：是為完成特定任務、用某種預研編寫的一組指令的集合。即指一段靜態的代碼，靜態對象 進程（process）：是程序的依次執行過程，

並發編程之多線程基礎-線程五種狀態(三)

獲得 png 完成 () 計算 .cn 其他 logs 正在 原文地址:https://www.cnblogs.com/wangyichuan/p/5990821.html 線程從創建、運行到結束總是處於下面五個狀態之一：新建狀態、就緒狀態、運行狀態、阻塞狀態及

多線程基礎二（線程的啟動、終止，線程面臨的三種問題）

主線程 影響 stop pub atom out 通過 println 性問題 一、線程的啟動、終止方式 　啟動：　start native（調用外部接口啟動） 終止： stop(類似kill,暴力終止) interrupt 中斷的方式 通過指令的方式 v

Java多線程實現的三種方式

get() warning 三種方式 方式 緩存 運行 了解 ren ava Java多線程實現方式主要有三種：繼承Thread類、實現Runnable接口、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後

Linux多線程實踐（三）線程的基本屬性設置API

ets evel 內核 system 範圍 ack jsb sig 溢出 POSIX 線程庫定義了線程屬性對象 pthread_attr_t ，它封裝了線程的創建者能夠訪問和改動的線程屬性。主要包含例如以下屬性： 1. 作用域（scope） 2. 棧尺寸（s

Java 多線程基礎

xtend 當前 nds nth list 相同 pid 概念 主線程 1.多線程基礎 1）進程 　　進程（process）就是一塊包含了某些資源的內存區域。操作系統利用進程把它的工作劃分為一些功能單元。進程中所包含的一個或多個執行單元成為線程（threa

一起talk C栗子吧（第一百一十九回：C語言實例--線程死鎖三）

取數 string value reading sel 一個 second key 而且 各位看官們。大家好，上一回中咱們說的是線程死鎖的樣例，這一回咱們繼續說該樣例。閑話休提，言歸正轉。讓我們一起talk C栗子吧！ 看官們，由於篇幅的原因我們

Java多線程基礎（二）

常用 進程上下文 技術 進入 返回 ren 說明 多線程基礎 常用api 基本概念 進程：程序的執行過程。持有資源（共享內存、共享文件）和線程。 線程： - 是一個程序內部的順序控制流。 - 它包含在進程之中，是系統中最小執行單元，同一個進程可以有多個線程。 - 線程共享進

JAVA線程同步 （三）信號量

ole 給定 如何 package 分配 exec 大量 復制代碼 離開 一個信號量有且僅有3種操作，且它們全部是原子的：初始化、增加和減少 增加可以為一個進程解除阻塞； 減少可以讓一個進程進入阻塞。 信號量維護一個許可集，若有必要，會在獲得許可之前阻塞每一個線程：

iOS開發中多線程基礎

推斷 傳遞 cti self reads priority cal default value 耗時操作演練 代碼演練 編寫耗時方法 - (void)longOperation { for (int i = 0; i <

【基礎知識三】線性模型

解決方法 最小 方法 不能 其余 比例 http 正則 註意 一、基本形式 通過屬性的線性組合來進行預測， 許多非線性模型可以在線性模型的基礎上，引入層級結構或高維映射而得。 二、線性回歸 最小二乘法：求解ω和b； 多元線性回歸：樣本由多個屬性描述，即x為多維向量； 若矩

java 內存模型和多線程基礎

java 技術 blog 分享 nbsp 多線程基礎 ima image ges java 內存模型和多線程基礎

java多線程基礎

很難 thread 結束 就會 線程 () cpu zed ron wait和notify是針對sychronized鎖定對象的 sychronized(object)object.wait();//釋放object的鎖sychronized(object)object.n

【Java系列】【基礎版】多線程基礎

java多線程基礎1.1 認識進程和線程1.1.1 什麽是進程 1.1.1.1 進程是正在進項的程序，是資源分配的一個基本單位，有內存分配；1.1.2 什麽是線程 1.1.2.1 線程是進程的一個執行單位，也是進程的執行順序； 1.1.2.2 一個進程至少有一個線程，可以由兩個或以上的線程

C#多線程基礎，適合新手了解

net 應用程序 sin pri rgs 工作 而在 了解 thread 一、創建線程 　　在整個系列文章中，我們主要使用Visual Studio 2015作為線程編程的主要工具。在C#語言中創建、使用線程只需要按以下步驟編寫即可： 1、啟動Visual Studio