多線程解決同步問題淺析

一，問題背景

1.為什么要引入多線程？

     用多線程只有一個目的，那就是更好的利用cpu的資源，因為所有的多線程代碼都可以用單線程來實現。說這個話其實只有一半對，因為反應“多角色”的程序代碼，最起碼每個角色要給他一個線程吧，否則連實際場景都無法模擬，當然也沒法說能用單線程來實現：比如最常見的“生產者，消費者模型”。

2.多線程、同步、並發概念：

多線程：指的是這個程序（一個進程）運行時產生了不止一個線程。
並行：多個cpu實例或者多台機器同時執行一段處理邏輯，是真正的同時。
並發：通過cpu調度算法，讓用戶看上去同時執行，實際上從cpu操作層面不是真正的同時。並發往往在場景中有公用的資源，那么針對這個公用的資源往往產生瓶頸，我們會用TPS或者QPS來反應這個系統的處理能力。

3.引入多線程后會帶來那些問題？

      java允許多線程並發控制，當多個線程同時操作一個可共享的資源變量時（如數據的增刪改查），將會導致數據不准確，相互之間產生沖突，因此加入同步鎖以避免在該線程沒有完成操作之前，被其他線程的調用，從而保證了該變量的唯一性和准確性。

以買票系統為例，我們發現不加控制多線程會出現超賣現象。

public class RunnableImpl implements Runnable {

private int ticket=100;
    @Override
    public void run() {
        while(true){
            if (ticket<=0){
                break;
            }
            try {
                Thread.sleep(200);
                String name = Thread.currentThread().getName();
                System.out.println("第"+name+"窗口正在賣出第"+(200-ticket+1)+"張票，剩余"+(--ticket)+"張");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }



    }
}

測試類：

public class originticket {
    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
       new Thread(runnable,"一").start();
       new Thread(runnable,"二").start();
    }
}

 

結果顯示：

 

二,問題解決方案之synchronize代碼塊：

public class RunnableImplsyn implements Runnable {

private int ticket=200;
    @Override
    public void run() {
        while(true) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this) {
            if (ticket <= 0) {
                break;
            }


                    String name = Thread.currentThread().getName();
                    System.out.println("第" + name + "窗口正在賣出第" + (200 - ticket + 1) + "張票，剩余" + (--ticket) + "張");


            }
        }


    }
}

測試類：

public class synchronizeblockTicket {

    public static void main(String[] args) {
        RunnableImplsyn runnableImplsyn = new RunnableImplsyn();
        new Thread(runnableImplsyn,"一").start();
        new Thread(runnableImplsyn,"二").start();
    }
}

結果：

三，問題解決方案之synchronize方法：

這里抽取了方法，this代指：

public class RunnableImplsynfn implements Runnable {

private static int ticket=200;
    @Override
    public void run() {
       test();
   
    }


    private synchronized void test() {
        while(true){
            if (ticket<=0){
                break;
            }
            try {
                Thread.sleep(200);
                String name = Thread.currentThread().getName();
                System.out.println("第"+name+"窗口正在賣出第"+(200-ticket+1)+"張票，剩余"+(--ticket)+"張");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }



    }
    }

測試類：

public class synchronizefnTicket {


    public static void main(String[] args) {
        RunnableImplsynfn runnableImplsyn = new RunnableImplsynfn();
        new Thread(runnableImplsyn,"一").start();
        new Thread(runnableImplsyn,"二").start();
    }
}

四，問題解決方案之靜態synchronize方法：

同上

public class RunnableImplsynfn implements Runnable {

private static int ticket=200;
    @Override
    public void run() {
        statictest();

    }

    private static synchronized void statictest() {
        while(true){
            if (ticket<=0){
                break;
            }
            try {
                Thread.sleep(200);
                String name = Thread.currentThread().getName();
                System.out.println("第"+name+"窗口正在賣出第"+(200-ticket+1)+"張票，剩余"+(--ticket)+"張");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
   

    }
    }

測試類一樣略。

五，問題解決方案之lock方法：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Runnablelock implements Runnable {
    private int ticket=200;
   Lock l= new ReentrantLock();

    @Override
    public void run() {
        while(true){
 /*       try {
        Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
l.lock();//從此以后加鎖

            if (ticket<=0){
                break;
            }
            try {
                Thread.sleep(200);

                String name = Thread.currentThread().getName();
                System.out.println("第"+name+"窗口正在賣出第"+(200-ticket+1)+"張票，剩余"+(--ticket)+"張");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                l.unlock();//釋放鎖
            }

        }


    }
}

測試類：

public class lockTicket {


    public static void main(String[] args) {
        Runnablelock runnablelock = new Runnablelock();
        new Thread(runnablelock,"一").start();
        new Thread(runnablelock,"二").start();
    }
}