day14-并发问题

线程并发

废话不多说，上例子

//多个线程同时操作同一个对象
//抢购小米11的例子
public class TestThread4 implements Runnable{

    //库存
    private int phoneNums = 10;


    @Override
    public void run() {
        while (true){

            if(phoneNums <=0)break;
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+phoneNums --+"台");
        }
    }

    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();

        new Thread(testThread4,"小米11").start();
        new Thread(testThread4,"雷军耍猴").start();
        new Thread(testThread4,"买不到无货").start();
    }

}

上结果

买不到无货拿到了第10台
小米11拿到了第9台
雷军耍猴拿到了第10台
雷军耍猴拿到了第8台
小米11拿到了第6台
买不到无货拿到了第7台
雷军耍猴拿到了第5台
小米11拿到了第5台
买不到无货拿到了第4台
小米11拿到了第3台
雷军耍猴拿到了第2台
买不到无货拿到了第1台
雷军耍猴拿到了第0台
小米11拿到了第-1台

我们可以发现一个并发问题

多线程操作同一个资源的情况下，线程不安全，数据紊乱

我们来分析一下代码
先不去看psvm

1. 首先定义了一个Buy接口
2. 真实角色You实现了该接口
3. 代理角色MonkeyKing也实现了该接口
4. 并在代理角色中添加了一个Buy target对象
5. 再用构造器，将该对象注入到代理角色

以上分析，我们就知道了可以用代理对象来操作真实对象，
也就是"耍猴"操作了"8+256小米11无货".

好处就是，
代理对象可与做很多真实对象做不了的事情
真实对象专注做自己的事情

那么我们这里采用sleep的方式让线程自动休眠

这里举一个例子龟兔赛跑，

package testThread;

public class Race implements Runnable{

    private static String winner;

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            if(Thread.currentThread().getName().equals("兔子")&&i%5==0){
                try {
                    System.out.println("兔子睡觉了");
                    i+=3;
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序

            if(flag)break;

            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");

        }
    }

    //判断gameOver
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if(winner!=null){//已经存在胜利者
            return true;
        }else {
            if(steps >= 100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race= new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }

}

我这里的计算机时双核四线程，很可能只分配一个给程序用。就可能出现没有交替的情况。多试几次就好了。

实现Callable接口（了解即可）

1. 实现callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务:ExecutorService ser = Executors.newFixedThreadPool
5. 执行提交：Future result1 = ser.submit(t1);
6. 获取结果: boolean r1 = result1.get()
7. 关闭服务：ser.shutdownNow();

举个例子

package testThread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建：实现callable
public class TestCallable implements Callable<Boolean> {//这里Boolean必须和call方法的返回值类型一样
    private String URL;//网络图片地址
    private String name;//保存的文件名
    public TestCallable(String URL, String name) {
        this.URL = URL;
        this.name = name;
    }

    @Override
    public Boolean call(){
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(URL,name);
        System.out.println("下载的文件名为"+name);
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t0 = new TestCallable("https://i2.hdslb.com/bfs/face/83bb511365da513c55aa3d1958524f3b7db40684.jpg@64w_64h.webp","0.jpg");
        TestCallable t1 = new TestCallable("https://i2.hdslb.com/bfs/archive/0ae34a0c6347a0fd2ccc7f7f468d551ae4439326.jpg@336w_190h.webp","1.jpg");
        TestCallable t2 = new TestCallable("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@336w_190h.webp","2.jpg");

        //创建执行服务:ExecutorService ser = Executors.newFixedThreadPool
        ExecutorService service  = Executors.newFixedThreadPool(3);

        //执行提交：Future result1 = ser.submit(t1);
        Future<Boolean> r1 = service.submit(t0);
        Future<Boolean> r2 = service.submit(t1);
        Future<Boolean> r3 = service.submit(t2);

        //获取结果: boolean r1 = result1.get()

        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        //关闭服务：ser.shutdownNow();
        service.shutdownNow();
    }
}

//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));//org.apache.commons.io.FileUtils类，将一个url复制为文件
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader出现问题");
        }
    }
}

静态代理模式

package Proxy;

public class StaticProxy {
    public static void main(String[] args) {
    	new Thread( ()-> System.out.println("猴王雷军")).start();//对比线程

        new MonkeyKing(new You()).MiHome();//对比静态代理
    }
}

interface Buy {
    void MiHome();
}

//真实角色
class You implements Buy {
    @Override
    public void MiHome() {
        System.out.println("8+256小米11蓝色无货");
    }
}


//代理角色
class MonkeyKing implements Buy {
    private Buy target;

    public MonkeyKing(Buy target) {
        this.target = target;
    }

    @Override
    public void MiHome() {
        before();
        this.target.MiHome();
        after();
    }

    private void before() {
        System.out.println("之前");
    }

    private void after() {
        System.out.println("之后");
    }
}

其实静态代理就是线程的底层实现原理，配合Runnable
YOU–>真实角色，类似于自己创建线程的。
MonkeyKing–>代理角色，类似于Thread类
买手机–>都实现BUY接口即可，类似于runnable接口