執行緒鎖與多執行緒

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

（1）

package day20150914sync;
/**
 * 執行緒併發安全問題
 */
public class SyncDemo1 {
    //桌子上有20個豆子
    public static int beans = 20;
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run(){
                int bean = 0;
                while(true){
                    bean = getBean();
                    Thread.yield();//讓執行緒延遲 

                    System.out.println(this.getName()+":"+bean);
                }
            }
        };

        Thread t2 = new Thread(){
            public void run(){
                int bean = 0;
                while(true){
                    bean = getBean();
                    Thread.yield();//讓執行緒延遲 

                    System.out.println(this.getName()+":"+bean);
                }
            }
        };

        t1.start();
        t2.start();
    }
    /**
     * synchronized:加鎖之後，
     * 單個執行緒徹底執行完方法後才釋放鎖
     * 方法鎖的物件是this
     */
    public synchronized static int getBean(){
        if(beans==0 
){
            throw new RuntimeException("沒豆子了");
        }
        try {
            Thread.sleep(50);//sleep50毫秒
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        return beans--;

    }

}
/*
 * 備註：
 * StringBuffer:執行緒安全
 * StringBuilder:執行緒不安全
 * 
 * 例如append的時候
 */

（2）

package day20150914sync;
/**
 * 有效減少同步範圍可提高效率
 *
 */
public class SyncDemo2 {
    private static Object obj = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            public void run(){
                buy(this.getName());//靜態方法不用點“.”
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                buy(this.getName());
            }
        };

        t1.start();
        t2.start();
    }
    //鎖住整個方法，類作為鎖，當前執行緒完全執行完方法後，其他執行緒才可使用此方法
    //public static synchronized void buy(String name){

    public static void buy(String name){
        System.out.println(name+"挑衣服");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //多個執行緒看到的是同一個物件，才具有同步效力
        /*
         * 如果synchronized塊在某一個非靜態方法中，
         * 那麼通常鎖物件寫的是this
         * 
         * 靜態方法中不能使用非靜態物件
         */
        synchronized (obj) {
            System.out.println(name + "開始試衣服。。。");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "試衣服結束。。。");
        }
        System.out.println(name+"結賬");
    }
}

（3）

package day20150914sync;
/**
 * 有效減少同步範圍可提高效率（非靜態方法）
 */
public class SyncDemo3 {
    public static void main(String[] args) {
        //匿名內部類使用demo,需要是final
        final SyncDemo3 demo = new SyncDemo3();
        Thread t1 = new Thread(){
            public void run(){
                demo.buy(this.getName());//匿名內部類使用demo,需要是final
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                demo.buy(this.getName());
            }
        };

        t1.start();
        t2.start();
    }
    /**非靜態方法
     */
    public void buy(String name){
        System.out.println(name+"挑衣服");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //多個執行緒看到的是同一個物件，才具有同步效力
        /*
         * 如果synchronized塊在某一個非靜態方法中，
         * 那麼通常鎖物件寫的是this
         * 
         * 靜態方法中不能使用非靜態物件
         */
        synchronized (this) {
            System.out.println(name + "開始試衣服。。。");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "試衣服結束。。。");
        }
        System.out.println(name+"結賬");
    }
}

（4）

package day20150914sync;

public class ThreadDemo4join {

    /**
     * 圖片是否下載完
     */
    public static boolean isFinish;
    public static void main(String[] args) {
        final Thread download = new Thread(){
            public void run(){
                /*
                 * 下載圖片
                 */
                System.out.println("開始下載圖片。。。");
                for(int i=1;i<=10;i++){
                    System.out.println(i+"0%");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("圖片下載完成");
                isFinish = true;

                /*
                 * 下載附件
                 */
                System.out.println("開始下載附件");
                for(int i=1;i<=10;i++){
                    System.out.println(i+"0%");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("附件下載完成");
            }
        };
        /**
         * 顯示圖片
         * 
         * main方法中定義了一個內部類show
         * 該內部類中若想引用main方法中的其他區域性變數
         * 那麼這個變數必須是final的
         */
        Thread show = new Thread(){         
            public void run(){
                //這裡等待圖片下載完成
                try {
                    download.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("開始顯示圖片");
                if(!isFinish){
                    throw new RuntimeException("圖片還沒有下載完成");
                }
                System.out.println("圖片開啟");
            }
        };


        download.start();       
        show.start();

    }

}

（5）

package day20150914sync;

public class ThreadDemo5waitnotify {

    /**
     * 圖片是否下載完
     */
    private static boolean isFinish;
    private static final Object obj = new Object();
    public static void main(String[] args) {
        final Thread download = new Thread(){
            public void run(){
                /*
                 * 下載圖片
                 */
                System.out.println("開始下載圖片。。。");
                for(int i=1;i<=10;i++){
                    System.out.println(i+"0%");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("圖片下載完成");
                isFinish = true;
                synchronized(obj){
                    /*
                     * 圖片下完，就當通知去顯示圖片
                     * notify()需要加鎖
                     * notify()只會隨機基礎一個在當前物件等待的執行緒
                     * notifyAll()全解除
                     * 
                     * 呼叫哪個物件的wait或notify,就應當對當前方法加鎖
                     * 鎖物件就是當前物件
                     */
                    obj.notify();//notifyAll():全部解除在等待的所有執行緒
                }

                /*
                 * 下載附件
                 */
                System.out.println("開始下載附件");
                for(int i=1;i<=10;i++){
                    System.out.println(i+"0%");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("附件下載完成");
            }
        };
        /**
         * 顯示圖片
         * 
         * main方法中定義了一個內部類show
         * 該內部類中若想引用main方法中的其他區域性變數
         * 那麼這個變數必須是final的
         */
        Thread show = new Thread(){         
            public void run(){
                //這裡等待圖片下載完成
                try {
                    //download.join();
                    synchronized(obj){
                        //在obj物件上等待，要加鎖
                        obj.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("開始顯示圖片");
                if(!isFinish){
                    throw new RuntimeException("圖片還沒有下載完");
                }
                System.out.println("圖片開啟");
            }
        };


        download.start();       
        show.start();

    }

}

（6）

package day20150914sync;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionsSynchronized6 {
    /**
     * 將集合或Map轉為執行緒安全的
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");

        //將List集合轉為執行緒安全的
        list = Collections.synchronizedList(list);
        System.out.println(list);

        //將Set集合轉為執行緒安全的
        Set<String> set = new HashSet<String>();
        set = Collections.synchronizedSet(set);
        //將Map轉為執行緒安全的
        Map<String, Integer> map = new HashMap<String, Integer>();
        map = Collections.synchronizedMap(map);

    }

}

（7）

package day20150914sync;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 執行緒池：
 * 1：控制執行緒數量
 * 2：重用執行緒
 */
public class ThreadPool7 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        for(int i=0;i<5;i++){
            Runnable runn = new Runnable(){

                @Override
                public void run() {
                    for(int i=0;i<4;i++){
                        System.out.println(i);
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                }

            };
            //Thread t = new Thread(runn);
            //t.start();
            threadPool.execute(runn);
        }
    }

}

執行緒鎖與多執行緒

（1） package day20150914sync; /** * 執行緒併發安全問題 */ public class SyncDemo1 { //桌子上有20個豆子 public static int beans = 20; p

Java執行緒安全與多執行緒開發

網際網路上充斥著對Java多執行緒程式設計的介紹，每篇文章都從不同的角度介紹並總結了該領域的內容。但大部分文章都沒有說明多執行緒的實現本質，沒能讓開發者真正“過癮”。從Java的執行緒安全鼻祖內建鎖介紹開始，讓你瞭解內建鎖的實現邏輯和原理以及引發的效能問題，接著說明了Java多執行緒程式設計中鎖的存在是為

java多執行緒：2、單執行緒程式與多執行緒程式

宣告：本教程不收取任何費用，歡迎轉載，尊重作者勞動成果，不得用於商業用途，侵權必究！！！文章目錄單執行緒程式多執行緒程式單執行緒程式在程序的地址空間當中，只有一個執行緒，由這一個執行緒來完成我們程式的執行任務。如：這就好像有一個患者要動手術，醫院由於人手緊

Python佇列與多執行緒及檔案鎖

佇列實現生產-多執行緒消費先看程式碼 # -*- coding: utf-8 -*- import queue import threading mu = threading.Lock() class Producer(threading.Thread): def __init__(

多執行緒四（多執行緒互鎖現象與等待喚醒機制）

最近在做與下載相關的APK的時候，需要用到多執行緒的一些知識，之前用的不是很多很深入，所以現在重新翻出來學習並且記錄一下，因為學習內容的調整，所以之前的部落格學習計劃有點變動；所以，在這裡先不給出具體的安排了，等這個模組過去之後，再重新更新一下這個系列標題與總介

c#中委託與多執行緒的實質

delegate（委託）的概念，.Net的委託本質上就是指向函式的指標，只不過這種指標是經過封裝後型別安全的。委託和執行緒是兩個不同的概念，執行緒是動態的，委託就是一個或一組記憶體地址，是靜態的。執行緒執行時如果遇到了指向函式的指標就執行這個函式。.Net為了方便程式設計，給委託賦予了兩種方式以供呼

第六章單例模式與多執行緒——立即載入“餓漢模式”與延遲載入“懶漢模式”

立即載入就是使用類的時候已經將物件建立完畢了，也稱為“餓漢模式” package test01; public class MyObject { // 建立物件 private static MyObject object = new MyObject(); private MyObjec

爬蟲與多執行緒

多執行緒和多程序爬蟲一.執行緒 1.什麼是執行緒。執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序中，是進城中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個執行緒可以併發多個執行緒，每條執行緒執行不同的任務。 2.執行緒常用的方法

C語言高階篇 - 4.連結串列&狀態機與多執行緒

1.連結串列的引入 1、從陣列的缺陷說起 (1)陣列有2個缺陷，一個是陣列中所有元素的型別必須一致；第二個是陣列的元素個數必須事先制定並且一旦指定之後不能更改。 (2)如何解決

【Linux】多程序與多執行緒之間的區別

http://blog.csdn.net/byrsongqq/article/details/6339240 網路程式設計中設計併發伺服器，使用多程序與多執行緒，請問有什麼區別？答案一: 1，程序：子程序是父程序的複製品。子程序獲得父程序資料空間、堆和棧的複製品。 2，執行緒：相

程序、執行緒與多執行緒

一、說說概念 1、程序（process）狹義定義：程序就是一段程式的執行過程。廣義定義：程序是一個具有一定獨立功能的程式關於某個資料集合的一次執行活動。它是作業系統動態執行的基本單元，在傳統的作業系統中，程序既是基本的分配單元，也是基本的執行單元。簡單的來講程序的概念主

多執行緒基礎7 多執行緒與併發庫

多執行緒與併發庫 BlockingQueue佇列 BlockingQueue,如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態,直到BlockingQueue進了東西才會被喚醒.同樣,如果BlockingQueue是滿的,任何試圖往裡存東西的操作

python之執行緒鎖與訊號量

執行緒鎖(互斥鎖Mutex) 一個程序下可以啟動多個執行緒，多個執行緒共享父程序的記憶體空間，也就意味著每個執行緒可以訪問同一份資料，此時，如果2個執行緒同時要修改同一份資料，會出現什麼狀況？就會可能存在同時取出了一個數據進行操作，然後存回去，這樣就會丟失一次操作。所以用鎖，在修改之前鎖上資料，

python多執行緒————8、多執行緒與多程序對比

#多程序程式設計 #耗cpu的操作，用多程序程式設計，對於io操作來說，使用多執行緒程式設計，程序切換代價要高於執行緒 import time from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor,as_compl

Java多執行緒學習筆記21之單例模式與多執行緒

詳細程式碼見:github程式碼地址第六章單例模式與多執行緒前言: 我之前已經開設了23個設計模式這個專欄，介紹了很多的Java設計模式，其中一些模式對於絕大多數程式語言設計思想都是類似的，需要了解單例模式的可以去看看。我們在實際開發中經常用到單例模式，但

探討kafka的分割槽數與多執行緒消費

kafka算是很麻煩的一件事兒，起因是最近需要採集大量的資料，原先是隻用了典型的high-level Consumer的API，最經典的不過如下： [java] view plain copy

執行緒（二）：執行緒開啟方式與多執行緒（threading模組）

目錄執行緒的建立Threading.Thread類 1）執行緒的建立 2）多執行緒與多程序 3）Thread類的其他方法 4）守護執行緒 multiprocess模組的完全模仿了threading模組的介面，二者在使用層面，有很大的相似性，因而不再詳細介紹（官方連結）

Java多執行緒——執行緒優先順序與守護執行緒（Daemon Thread）

一、執行緒優先順序每個執行緒都可以通過thread.setPriority()實現程序優先順序的設定。可設定的範圍在1-10之間，如果超過此範圍將丟擲異常throw new IllegalArgumentException()。每個執行緒的預設優先順序為5。 tips：即使將某個執行緒的優

JavaSE基礎學習筆記及案例(一)IO流與多執行緒(上)

IO流 1. IO流知識點 IO流(字元輸入流FileReader) 位元組輸入流 FileInputStream IO流(字元輸出流FileWriter) 位元組輸出流 FileOutputStream 字元緩衝區輸入流（ BufferedReader）位元組緩衝區輸入流Bu

鎖和多執行緒:執行緒建立3種方式(一)

執行緒鎖Synchronized 搞明白執行緒鎖和多執行緒系列 1.執行緒建立執行緒建立常見的三種方式: 繼承Thread類實現Runnable介面

執行緒鎖與多執行緒

相關推薦