代碼理解多線程（一）

原創 zzqtty 2020-06-11 12:18

 

多線程訪問會有什麼問題？？

 

public class TestMyThread extends Thread{
    

    //共享變量
    private int a = 5;
    
    //重寫run方法
    @Override
    public  void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //實列需要多線程的對象
        TestMyThread myThread = new TestMyThread();
        
        
        //創建多個線程實列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        
        
        //運行
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
        
    }
    
    
    
    
    
}

結果：

a is :3
a is :3
a is :2
a is :1
a is :0

a is :4
a is :3
a is :2
a is :1
a is :0

等等，你會發現每次出來的結果都不一樣，這就是多線程訪問的問題

 怎樣解決？？？

package test19218;

import test517designpattern.test;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread extends Thread{
    

    //共享變量
    private int a = 5;
    
    //重寫run方法
    @Override
    public synchronized void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //實列需要多線程的對象
        TestMyThread myThread = new TestMyThread();
        
        //創建多個線程實列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        
        
        //運行
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
        
    }
    
    
    
    
    
}

 

 我們加了synchronize關鍵字

a is :4
a is :3
a is :2
a is :1
a is :0

 結果是我們想要的。

那麼synchronize是鎖的對象myThread ，還是那一段代碼呢？

package test19218;

import test517designpattern.test;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread extends Thread{
    
    //共享變量
    private int a = 5;
    
    //重寫run方法
    @Override
    public synchronized void  run(){        
        a--;
        System.out.println("a is :"+ a);    
    }
    
    public static void main(String[] args) {
        
        
        //實列需要多線程的對象
        TestMyThread myThread = new TestMyThread();
        TestMyThread myThread2 = new TestMyThread();
        
        //創建多個線程實列
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread2,"t2");
        
        //運行
        t1.start();
        t2.start();
        
    }
    
}

 

 結果

a is :4
a is :4

 說明鎖住的是代碼。如果是鎖住的對象，那麼就應該減兩次纔對！！！

 /**
 * 關鍵字synchronized取得的鎖都是對象鎖，而不是把一段代碼（方法）當做鎖，
 * 所以代碼中哪個線程先執行synchronized關鍵字的方法，哪個線程就持有該方法所屬對象的鎖（Lock），
 *
 * 在靜態方法上加synchronized關鍵字，表示鎖定.class類，類一級別的鎖（獨佔.class類）。
 * @author alienware
 *
 */

 如果同一個對象，兩個方法，一個用synchronize修飾，另一個不用，我訪問非synchronize修飾的方法是否需要等待，其實就是是否會阻塞？

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    String tag;

    public TestMyThread02(String tag) {
        this.tag = tag;
    }

    public TestMyThread02() {
    }

    // 共享變量
    private int a = 5;

    // 方法
    public synchronized void deNum(String tag) throws InterruptedException {
        a--;
        Thread.sleep(1000);
        System.out.println(tag + "---a is :" + a);
    }

    // 方法
    public  void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 實列需要多線程的對象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 創建多個線程實列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum(t1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                myThread01.adNum(t2);

            }
        });

        // 運行
        th.start();
        th1.start();
    }

}

 

 結果

t2---a is :5
t1---a is :5

 t2先執行了，所以並不會阻塞。

如果兩個方法都加上synchronize呢？

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    String tag;

    public TestMyThread02(String tag) {
        this.tag = tag;
    }

    public TestMyThread02() {
    }

    // 共享變量
    private int a = 5;

    // 方法
    public synchronized void deNum(String tag) throws InterruptedException {
        a--;
        Thread.sleep(1000);
        System.out.println(tag + "---a is :" + a);
    }

    // 方法
    public synchronized  void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 實列需要多線程的對象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 創建多個線程實列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum(t1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                myThread01.adNum(t2);

            }
        });

        // 運行
        th.start();
        th1.start();
    }

}

 

 t1---a is :4
t2---a is :5

 進行阻塞

所以，當同一個對象中的兩個方法有邏輯聯繫的時候，你其中一個加了synchronize，那麼你另一個也應該加上，才能保證返回結果的正確。

 

鎖對象改變問題

package test19218;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月18日
 */

public class TestMyThread02 {

    private String tag = "tag";

    public TestMyThread02() {
    }

    // 共享變量
    private int a = 5;

    // 方法
    public void deNum() throws InterruptedException {

        synchronized (tag) {
            tag = "change tag";

            System.out
                    .println(Thread.currentThread().getName() + "sleep begin");
            Thread.sleep(6000);
            System.out.println(Thread.currentThread().getName() + "sleep over");
        }

    }

    // 方法
    public synchronized void adNum(String tag) {
        a++;
        System.out.println(tag + "---a is :" + a);
    }

    public static void main(String[] args) {

        final String t1 = "t1";
        final String t2 = "t2";

        // 實列需要多線程的對象
        final TestMyThread02 myThread01 = new TestMyThread02();
        // final TestMyThread02 myThread02 = new TestMyThread02();

        // 創建多個線程實列
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }, t1);

        Thread th1 = new Thread(new Runnable() {

            @Override
            public void run() {

                try {
                    myThread01.deNum();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }, t2);

        // 運行
        th.start();

        try {
            th1.sleep(100);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        th1.start();
    }

}

 

 th進入鎖以後改變對象，th1立刻就進入，沒有等t1執行完成

如果不改變鎖對象，那麼th1將等th執行完成後才進入。

 死鎖問題，

在設計程序時就應該避免雙方相互持有對方的鎖的情況

package com.bjsxt.base.sync006;

/**
 * 死鎖問題，在設計程序時就應該避免雙方相互持有對方的鎖的情況
 * @author alienware
 *
 */
public class DeadLock implements Runnable{

    private String tag;
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    
    public void setTag(String tag){
        this.tag = tag;
    }
    
    @Override
    public void run() {
        if(tag.equals("a")){
            synchronized (lock1) {
                try {
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock1執行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock2執行");
                }
            }
        }
        if(tag.equals("b")){
            synchronized (lock2) {
                try {
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock2執行");
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 進入lock1執行");
                }
            }
        }
    }
    
    public static void main(String[] args) {
        
        DeadLock d1 = new DeadLock();
        d1.setTag("a");
        DeadLock d2 = new DeadLock();
        d2.setTag("b");
        
        Thread t1 = new Thread(d1, "t1");
        Thread t2 = new Thread(d2, "t2");
        
        t1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
    

    
}

 

同一對象屬性的修改不會影響鎖的情況

 

package com.bjsxt.base.sync006;
/**
 * 同一對象屬性的修改不會影響鎖的情況
 * @author alienware
 *
 */
public class ModifyLock {
    
    private String name ;
    private int age ;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public synchronized void changeAttributte(String name, int age) {
        try {
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 開始");
            this.setName(name);
            this.setAge(age);
            
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 修改對象內容爲： "
                    + this.getName() + ", " + this.getAge());
            
            Thread.sleep(2000);
            System.out.println("當前線程 : "  + Thread.currentThread().getName() + " 結束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        final ModifyLock modifyLock = new ModifyLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("張三", 20);
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                modifyLock.changeAttributte("李四", 21);
            }
        },"t2");
        
        t1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
    
}

 

 使用synchronized代碼塊加鎖,比較靈活

 

package com.bjsxt.base.sync006;

/**
 * 使用synchronized代碼塊加鎖,比較靈活
 * @author alienware
 *
 */
public class ObjectLock {

    public void method1(){
        synchronized (this) {    //對象鎖
            try {
                System.out.println("do method1..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void method2(){        //類鎖
        synchronized (ObjectLock.class) {
            try {
                System.out.println("do method2..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    private Object lock = new Object();
    public void method3(){        //任何對象鎖
        synchronized (lock) {
            try {
                System.out.println("do method3..");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    public static void main(String[] args) {
        
        final ObjectLock objLock = new ObjectLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                objLock.method3();
            }
        });
        
        t1.start();
        t2.start();
        t3.start();
        
        
    }
    
}

 

 synchronized代碼塊對字符串的鎖，注意String常量池的緩存功能

package com.bjsxt.base.sync006;
/**
 * synchronized代碼塊對字符串的鎖，注意String常量池的緩存功能
 * @author alienware
 *
 */
public class StringLock {

    public void method() {
        //new String("字符串常量")
        synchronized ("字符串常量") {
            try {
                while(true){
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + "開始");
                    Thread.sleep(1000);        
                    System.out.println("當前線程 : "  + Thread.currentThread().getName() + "結束");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static void main(String[] args) {
        final StringLock stringLock = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                stringLock.method();
            }
        },"t2");
        
        t1.start();
        t2.start();
    }
}

 

 使用synchronized代碼塊減小鎖的粒度，提高性能

package com.bjsxt.base.sync006;

/**
 * 使用synchronized代碼塊減小鎖的粒度，提高性能
 * @author alienware
 *
 */
public class Optimize {

    public void doLongTimeTask(){
        try {
            
            System.out.println("當前線程開始：" + Thread.currentThread().getName() +
                    ", 正在執行一個較長時間的業務操作，其內容不需要同步");
            Thread.sleep(2000);
            
            synchronized(this){
                System.out.println("當前線程：" + Thread.currentThread().getName() +
                    ", 執行同步代碼塊，對其同步變量進行操作");
                Thread.sleep(1000);
            }
            System.out.println("當前線程結束：" + Thread.currentThread().getName() +
                    ", 執行完畢");
            
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        final Optimize otz = new Optimize();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                otz.doLongTimeTask();
            }
        },"t2");
        t1.start();
        t2.start();
        
    }
    
    
}

 

 多個addAndGet在一個方法內是非原子性的，需要加synchronized進行修飾，保證4個addAndGet整體原子性

package other;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月19日
 */

public class AtomicTest {

    //變量爲atomic系列
    private  AtomicInteger num = new AtomicInteger(0);
    
    //多次自增 synchronized
    public   void addNum(){
     int i =    num.incrementAndGet();
     System.out.println("now  num is :" + i);
    
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
    
    }
    
    
    public static void main(String[] args) {
        
        
        //實列需要多線程對象
        final AtomicTest test  = new AtomicTest();
        
        
        //起多個線程運行
        for(int i = 0;i<=100;i++){
            
            //System.out.println("now time is : "+ i);
            Thread t = new Thread(new Runnable() {                
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    test.addNum();
                }
            });
            
            //啓動
            t.start();
        }
    }
    
}

 

結果：

now  num is :418
now  num is :433
now  num is :432

 結果是亂的，加上synchronize之後

    //多次自增 synchronized
    public  synchronized   void addNum(){
     int i =    num.incrementAndGet();
     System.out.println("now  num is :" + i);
    
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
     num.incrementAndGet();
    
    }

 now  num is :486
now  num is :491
now  num is :496
now  num is :501

 輸出結果總是一直且有序

 volatile關鍵字不具備synchronized關鍵字的原子性（同步）

 

package other;

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

import com.mysql.fabric.xmlrpc.base.Array;

/**
 * @Description
 * @Author zengzhiqiang
 * @Date 2019年2月19日
 */

public class VolatileTest {

    //變量
    private volatile int num  = 0;
    
    
    //變量的自增   synchronized
    public  void addNum(){
        num++;
        num++;
        System.out.println("now num is :" + num);
    }
    
    public static void main(String[] args) {
        
        //多線程實列對象
        final VolatileTest test =  new VolatileTest();
        
        //定義多線程列表
        List<Thread> list = new  ArrayList<Thread>();
        
        
        //初始化多個線程
        for(int i = 0;i<100;i++){
            Thread t = new Thread(new Runnable() {
                
                @Override
                public void run() {
                test.addNum();
                    
                }
            });
            
            list.add(t);
        }
        
        
        //啓動多線程
        for(Thread th:list){
            th.start();
        }
        
    }
    
}

 

 結果

now num is :188
now num is :188
now num is :186
now num is :186

 無序，顯示不正確，但是結果爲200，正確

使用synchronize修飾

    //變量的自增   synchronized
    public  synchronized  void addNum(){
        num++;
        num++;
        System.out.println("now num is :" + num);
    }

結果

now num is :194
now num is :196
now num is :198
now num is :200

 有序，顯示正確，且結果正確。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

簡單談談線程

進程與線程？ 多任務：同一時刻運行多個程序的能力。每一個任務稱爲一個線程。可以同時運行一個以上線程的程序稱爲多線程程序。 Java編寫程序都運行在在Java虛擬機（JVM）中，在JVM的內部，程序的多任務是通過線程來實現的。每用j

IT小白098 2020-07-08 09:44:07

一文講透“進程，線程和協程”

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 本文從操作系統原理出髮結合代碼實踐講解了以下內容： 什麼是進程，線程和協程？ 它們之間的關係是什麼？ 爲什麼說Python中的多線程是僞

雲棲號資訊小哥 2020-08-05 15:37:51

連續 3 年最受歡迎：Rust，香！

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 阿里妹導讀：我們在選擇一種開發語言時會綜合考量各方面的特性，根據實際的需求適當取捨。魚和熊掌往往不可兼得，要想開發效率高，必然要犧牲性能

雲棲號資訊小編 2020-07-21 13:01:52

Python初學者的自我修養，找到自己的方向

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 上週的文章當中我們簡單介紹了線程和進程的概念，以及在Python當中如何在主線程之外創建其他線程，並且還了解了用戶級線程和後臺線程的區別以

雲棲號資訊小哥 2020-07-16 15:19:52

java多線程方式導入excel數據入數據庫

需求： 最近項目寫了poi導入excel數據到數據庫，在代碼上已經算是很優了，雖然領導沒有要求我優化導入接口，但是本着技術而言，想把學到的知識用於實踐，於是使用多線程方式導入excel。 所需pow依賴: <dependenc

weixin_42982636 2020-07-08 11:21:30

Linux C/C++編程之（十七）進程間通信

文章目錄一、概述二、進程間通信概念及方法1. 管道的概念2. pipe3. 管道的讀寫行爲4. 管道緩衝區大小5. 管道優劣6. FIFO7. 共享存儲映射8. mmap函數9. munmap函數10. mmap九問11. mma

我是管小亮 2020-07-08 10:47:44

6.4 ThreadPoolExecutor線程池的關閉方法shutdown和shutdownNow區別、示例

shutdown(): 把線程池的狀態設置成SHUTDOWN狀態，然後中斷所有沒有正執行任務的線程 shutdownNow(): 首先把線程池的狀態設置成STOP,然後嘗試停止所有正在執行任務或者暫停任務的線程，並返回等待執行任務的列表

一点光辉 2020-07-08 10:46:31

linux下的線程池的實現

以爲自己設計的一個線程池操作樣例，參考libwebsocket 的源碼中的線程池實現 /* * File name : cetthreadpool.c * * Created on : 2020年5月13日 17:02:20 *

xiyuan255 2020-07-08 10:33:42

多線程輪流交替執行三種實現方法

第一種方法：採用公平鎖實現 思路及其簡單： A線程拿到鎖，執行代碼 B線程拿到鎖，執行代碼 A線程拿到鎖，執行代碼 ...... public class FairLockDemo { public static void m

沐雨金鳞 2020-07-08 10:30:45

想要職級到P7，啃完這946頁阿里P8面試官都說詳細的神仙文檔足矣

前言 應廣大粉絲要求，網上太多資料不夠詳細，不夠全面，花了很多心思去收集，到頭來發現並不全面，於是出現了本文，筆者在GitHub上找了很久終於找到了三份最全的Java學習筆記，總頁數946頁！ 涵蓋知識： 面試必問的：Java基礎、高併發

mrchaochao 2020-07-08 10:00:46

多線程Syschronized

場景（線程不安全） 需求（解決線程安全問題） 解決方案（Syschronized） 應用（Syschronized的幾種使用： 實例鎖（等同於同步代碼塊的this）， 靜態方法鎖（等同同步代碼塊的object.class)， 代碼

qq_43516647 2020-07-08 09:39:18

ReentrantReadWriteLock——讀寫鎖如何升級，爲何讀寫鎖不能插隊？

我們主要探討讀鎖應該插隊嗎?以及什麼是讀寫鎖的升降級。 讀鎖插隊策略：     首先，我們來看一下讀鎖的插隊策略，在這裏先快速回顧一下在 24 課時公平與非公平鎖中講到的 ReentrantLock，如果鎖被設置爲非公平，那麼它是可以在前

zhangkaixuan456 2020-07-08 07:49:43

LeetCode（1195）：交替打印字符串 Fizz Buzz Multithreaded（JUC）

2020.7.7 LeetCode 從零單刷個人筆記整理（持續更新） github：https://github.com/ChopinXBP/LeetCode-Babel 傳送門：交替打印字符串 Write a program

NJU_ChopinXBP 2020-07-08 06:56:30

Handler這些巧妙設計你知道多少？

Handler問題思考？ 線程間通信機制是什麼？怎麼完成線程間通信的？ 由什麼組成？ 調度策略是什麼樣的？消息循環機制，消息分發機制？ 爲什麼這麼設計？ 1. 線程間通信機制Handler Handler 是典型的生產者-消費者模型。是

涂程 2020-07-08 06:07:33

在windows下配置pthread多線程

        Pthread是由POSIX提出的一套通用的線程庫，在linux平臺下，它被廣泛的支持，而windows平臺下，卻並不被支持，而pthreads-w32爲我們提供瞭解決方案，本文我們準備在我們的windows平

对望小秘 2020-07-08 05:41:08