多线程解决同步问题浅析

一，问题背景

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();
    }
}