多线程知识总结

多线程

1、线程简介

1.1、关键字：任务、进程、进程、多线程

1.2、普通方法调用和多线程

1.3、核心概念

线程是独立的执行路劲
在程序运行时，及时没有自己创建线程，后台也会有多个线程，如主线程，gc线程
main()称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与OS密切相关的，先后顺序是不能人为的干预的
对于同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度时间，并发控制开销
每个线程在自己的工作内存交互，内存控制不会造成数据不一致

2、线程实现（重点）

1、继承Thread类（重点）

实现过程：

自定义线程类继承Thread类
重写run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

测试代码：

package per.mobian.thread;

//实现Thread接口
public class TestThread01 extends Thread {
    //实现接口后，重写里面的run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("执行测试线程" + i);
        }
    }
    public static void main(String[] args) {

        //开启多线程，实例化类，并且调用它的start()方法
        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了主线程" + i);
        }
    }
}

执行结果：

执行了主线程0
执行了主线程1
执行了主线程2
执行测试线程0
执行测试线程1
执行测试线程2
执行了主线程3
执行测试线程3
执行了主线程4
执行测试线程4

测试小案例：

编写一个多线程的下载程序，用于实现在网络上下载图片

package per.mobian.thread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//4.继承Thread方法
public class TestThread2 extends Thread {
    private String url;
    private String name;

    //构造方法
    public TestThread2(String url, String name) {
        this.url = url;
        this.name = name;
    }

    public TestThread2() {
    }

    //5.重写run()方法
    @Override
    public void run() {
        //6.实例化下载器类，并且调用下载器类的下载文件的方法
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downLoader(url, name);
        System.out.println("下载了文件" + name);
    }

    public static void main(String[] args) {
        //7.实例化线程类，再开启这个类的多线程
        TestThread2 t1 = new TestThread2("http://pic1.win4000.com/wallpaper/2017-11-17/5a0e94afc140c.jpg", "1.jpg");
        TestThread2 t2 = new TestThread2("http://ppic.meituba.com/uploads/allimg/2016/10/11/158_888.jpg", "2.jpg");
        TestThread2 t3 = new TestThread2("http://img.juimg.com/tuku/yulantu/110715/9128-110G514440969.jpg", "3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}

//1.编写一个下载器
class WebDownloader {
    //2.编写一个下载器类的下载方法
    public void downLoader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("方法出现IO异常");
        }
    }
}

测试结果：

下载了文件2.jpg
下载了文件3.jpg
下载了文件1.jpg

注意：

编写下载器类的时候，需要导入commons-io-2.6.jar （版本自选）
用IDEA复制jar包到lib目录下后，需要点击Add as library添加到 library中
图片的网络地址，需要自选

2、实现Runnable接口（重点）

实现过程：

定义MyRunnable类实现Runnable接口
实现run()方法，编写线程执行体
创建线程对象，调用start()方法启动线程

测试代码：

package per.mobian.thread;

//实现了Runnable接口
public class TestRunndble01 implements Runnable {
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了多线程方法" + i);
        }
    }

    public static void main(String[] args) {
        //实例化多线程类
        TestRunndble01 testRunndble01 = new TestRunndble01();
        //使用实现接口的方式，开启多线程（Thread的源码也就是实现Runnable接口），此处的实现方式与静态代理的设计模式有关
        new Thread(testRunndble01).start();
        for (int i = 0; i < 5; i++) {
            System.out.println("执行了主线程的方法" + i);
        }
    }
}

执行结果：

执行了主线程的方法0
执行了多线程方法0
执行了主线程的方法1
执行了多线程方法1
执行了多线程方法2
执行了多线程方法3
执行了主线程的方法2
执行了多线程方法4
执行了主线程的方法3
执行了主线程的方法4

对应于之前的小测试的修改：

//实现方式变成实现接口
public class TestRunnable02 implements Runnable

//使用此方法进行调用多线程
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();

3、两种方式的比较

继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

4、龟兔赛跑小案例

测试代码：

package per.mobian.thread;

public class TestRunnable04 implements Runnable {
    //胜利者
    private static String winner;
    
    //模拟龟兔赛跑的步数
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag == true) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
        }
    }
    //判断是否完成比赛
    public boolean gameOver(int steps) {
        //在第一个到达20米的时候，winner被赋值
        if (winner != null) {
            return true;
        } else {
            if (steps >= 20) {
                winner = Thread.currentThread().getName();
                System.out.println(winner + "是胜利者");
                return true;
            } else {
                return false;
            }
        }
    }

    //main()方法开启多线程
    public static void main(String[] args) {
        TestRunnable04 t1 = new TestRunnable04();
        new Thread(t1, "兔子").start();
        new Thread(t1, "乌龟").start();
    }
}

执行而结果：

//此结果中，兔子只跑了1米
乌龟跑了1米
乌龟跑了2米
乌龟跑了3米
乌龟跑了4米
乌龟跑了5米
乌龟跑了6米
乌龟跑了7米
兔子跑了1米
乌龟跑了8米
乌龟跑了9米
乌龟跑了10米
乌龟跑了11米
乌龟跑了12米
乌龟跑了13米
乌龟跑了14米
乌龟跑了15米
乌龟跑了16米
乌龟跑了17米
乌龟跑了18米
乌龟跑了19米
乌龟是胜利者

4、实现Callable接口（了解）

实现过程：

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

测试代码：

package per.mobian.thread;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;

    public TestCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    public TestCallable() {
    }

    @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 t1 = new TestCallable("http://pic1.win4000.com/wallpaper/2017-11-17/5a0e94afc140c.jpg", "1.jpg");
        TestCallable t2 = new TestCallable("http://ppic.meituba.com/uploads/allimg/2016/10/11/158_888.jpg", "2.jpg");
        TestCallable t3 = new TestCallable("http://img.juimg.com/tuku/yulantu/110715/9128-110G514440969.jpg", "3.jpg");

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

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

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //打印执行成功后的布尔值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

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

class WebDownloader {
    public void downLoader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("方法出现IO异常");
        }
    }
}

执行结果：

下载了文件3.jpg
下载了文件2.jpg
下载了文件1.jpg
true
true
true

5、静态代理模式（多线程底层实现）

测试代码：

package per.mobian.thread;

//定义接口，对比多线程的Runnable接口
interface Marry {
    void happyMarry();
}
//定义测试类
public class TestStaticProxy {
    public static void main(String[] args) {
        //正常的实现多线程的方法
//        WeddingCompany weddingCompany = new WeddingCompany(new You());
//        weddingCompany.happyMarry();

        //使用化简以后的，实现多线程的方法
         new WeddingCompany(new You()).happyMarry();

        //使用使用匿名内部类（直接new接口，重写接口方法），实现多线程的方法
        new Thread(new Runnable() {
            @Override
            public void run() {
            }
        }).start();
    }
}

//定义真实角色，对标实现Runnable类的具体执行类
class You implements Marry {
    @Override
    public void happyMarry() {
        System.out.println("默辨结婚了");
    }
}

//定义代理角色婚庆公式，对标Thread类
class WeddingCompany implements Marry {
    private Marry target;
    public WeddingCompany(Marry target) {
        this.target = target;
    }
    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();
        after();
    }
    private void before() {
        System.out.println("这是结婚之前");
    }
    private void after() {
        System.out.println("这是结婚之后");
    }
}

执行结果：

这是结婚之前
默辨结婚了
这是结婚之后

总结：

多线程的实现方式就是利用了静态代理模式。我们转到源码

//Runnable接口
public interface Runnable {
    public abstract void run();
}
//正常的带参的Thread方法的源码，次类为静态代理类，代理我们自己编写的多线程方法
public Thread(Runnable target) {
    this(null, target, "Thread-" + nextThreadNum(), 0);
}

//自己定义的多线程类分为两种，由于Thread类底层也是实现了Runnable接口的，所以我将两者都归类为实现接口的方式
class Thread implements Runnable {
    //调用此方法就类似于调用结婚这个方法
    public synchronized void start() {
        if (threadStatus != 0){
            throw new IllegalThreadStateException();
        }
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
}

3、Lambda表达式

λ java8特性

λ希腊希姆表中排序第是一位的字母，英文名称为Lamda
避免匿名内部类定义过多
其实质属于函数式编程概念

1、函数式接口的定义

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

public interface Runnable{
    public abstract void run();
}

2、对于函数式接口，我们可以使用Lamda表达式来创建该接口的对象

测试代码：Lambda的演变（五种定义类的方式：外部类、静态内部类、局部内部类、匿名内部类、Lambda表达式）

package per.mobian.thread;

//定义一个函数式接口
interface ILike {
    void Lambda();
}
//定义一个接口的实现类(正常的实现方法)
class Like implements ILike {
    @Override
    public void Lambda() {
        System.out.println("执行了Lambda表达式1");
    }
}

public class TestLambda {
    //2、使用静态内部类的方式实现
    static class Like2 implements ILike {
        @Override
        public void Lambda() {
            System.out.println("执行了Lambda表达式2");
        }
    }
    
    public static void main(String[] args) {
        //3、使用局部内部类的方式
        class Like3 implements ILike {
            @Override
            public void Lambda() {
                System.out.println("执行了Lambda表达式3");
            }
        }
        //1、正常的实现方法
        ILike like = new Like();
        like.Lambda();

        //2、使用静态内部类的方式实现
        like = new Like2();
        like.Lambda();

        //3、使用局部内部类的方法
        like = new Like3();
        like.Lambda();

        //4、使用匿名内部类,类没有名字，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void Lambda() {
                System.out.println("执行了Lambda表达式4");
            }
        };
        like.Lambda();

        //5、使用Lambda表达式(直接复制接口方法后面的所有代码再加上->即可)
        like = () ->{
            System.out.println("执行了Lambda表达式5");
        };
        like.Lambda();
    }
}

执行结果：

执行了Lambda表达式1
执行了Lambda表达式2
执行了Lambda表达式3
执行了Lambda表达式4
执行了Lambda表达式5

带参数的测试代码：

package per.mobian.thread;

interface ILove {
    void love(int a);
}

public class TestLambda2 {
    public static void main(String[] args) {
        ILove iLove = null;

        //1.lambda表示简化
        iLove = (int a) -> {
            System.out.println("a是：" + a);
        };
        iLove.love(1);

        //简化1、参数类型
        iLove = (a) -> {
            System.out.println("a是：" + a);
        };
        iLove.love(2);
        //简化2、简化括号
        iLove = a -> {
            System.out.println("a是：" + a);
        };
        iLove.love(3);

        //简化3、去掉花括号
        iLove = a -> System.out.println("a是：" + a);
        iLove.love(4);
    }
}

测试结果：

a是：1
a是：2
a是：3
a是：4

总结：

化简2与化简3的前提是，参数和方法体只有一条语句，超出范围则无法使用
使用函数式简化的前提为，接口为函数式接口
正常情况使用化简1的样式即可

3、线程状态

1、线程的五种状态的切换

2、停止线程

注意事项：

不推荐使用JDK提供的stop()、destory()方法
推荐线程自己停止下来
建议使用一个标志位进行终止变量，当flag=false，则终止线程运行

测试代码：

package pers.mobian.thread;

public class TestStopThread implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            System.out.println("我是多线程程序，我还在运行:" );
        }
    }

    //手写外部程序用于中断多线程程序的执行
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStopThread testStopThread = new TestStopThread();
        new Thread(testStopThread).start();
        for (int i = 1; i < 5; i++) {
            System.out.println("主方法执行次数：" + i);
            //中断程序执行的外部条件
            if (i == 2) {
                testStopThread.stop();
            }
        }
    }
}

测试结果：

我是多线程程序，我还在运行:
我是多线程程序，我还在运行:
我是多线程程序，我还在运行:
主方法执行次数：1
主方法执行次数：2
我是多线程程序，我还在运行:
主方法执行次数：3
主方法执行次数：4

3、线程休眠

注意事项：

sleep(时间) 指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会是方法锁

利用线程休眠，制作一个打印当前时间的案例：

package pers.mobian.thread;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleepThread {
    public static void main(String[] args) throws InterruptedException {

        //打印当前时间
        Date startTime = new Date(System.currentTimeMillis());
        while(true) {
            Thread.sleep(1000);
            //根据指定格式，打印时间
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
            //重新赋值时间，跟新时间
            startTime = new Date(System.currentTimeMillis());
        }
    }
}

执行结果：

16:40:49
16:40:50
16:40:51
16:40:52

4、线程礼让

注意事项：

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪转状态
让cpu重新调度，礼让不一定成功，看cpu心情

测试代码：

package pers.mobian.thread;

public class TestYieldThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程执行结束");
    }
    
    public static void main(String[] args) {
        TestYieldThread t1 = new TestYieldThread();
        new Thread(t1,"a线程：").start();
        new Thread(t1,"b线程：").start();
    }
}

执行结果：

//此结果为礼让成功
a线程：线程执行开始
b线程：线程执行开始
a线程：线程执行结束
b线程：线程执行结束

5、Join 强制执行

注意事项：

Join合并线程，待此线程执行完成后，再执行其他的线程，其他线程阻塞
可以想象成插队

测试代码：

package pers.mobian.thread;

public class TestJoinThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("我是多线程任务，我是插队的VIP");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoinThread testJoinThread = new TestJoinThread();
        new Thread(testJoinThread).start();

        for (int i = 0; i < 1000; i++) {
            if(i == 100) {
                new Thread(testJoinThread).join();
            }
            System.out.println("主方法执行次数："+i);
        }

    }
}

执行结果：

//如果执行是先主方法，则当i=100的时候，执行多线程任务，直到多线程任务执行结束，才返回之前执行的主方法

6、观测线程状态

package pers.mobian.thread;

public class TestStateThread {
    public static void main(String[] args) throws InterruptedException {

        //使用lambda表达式，新建一个多线程任务
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("\\\\\\");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        System.out.println("===");

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//Run
        System.out.println("===1");

        //当线程状态是停止（terminated）的时候，跳出循环
        while (state != Thread.State.TERMINATED) {
            Thread.sleep(1000);
            state = thread.getState();
            System.out.println(state);
        }

        thread.start();//线程死亡后，无法再次开启
    }
}

执行结果：

NEW
===
RUNNABLE
===1
TIMED_WAITING
TIMED_WAITING
RUNNABLE
TIMED_WAITING
RUNNABLE
\\\
    //最后异常是因为线程死亡后的再次启动报错
Exception in thread "main" java.lang.IllegalThreadStateException
TERMINATED
at java.base/java.lang.Thread.start(Thread.java:794)
at pers.mobian.thread.TestStateThread.main(TestStateThread.java:34)

总结：

7、线程的优先级

测试代码：

package pers.mobian.thread;

public class TestPriorityThread implements Runnable {
    public static void main(String[] args) {
        TestPriorityThread testPriorityThread = new TestPriorityThread();
        Thread t1 = new Thread(testPriorityThread);
        Thread t2 = new Thread(testPriorityThread);
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority());
        t1.start();

        //设置优先级,当设置的范围不再1-10，则会抛出异常
        t2.setPriority(8);
        t2.start();
    }

    @Override
    public void run() {
        //打印线程名字和线程优先级
        System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority());
    }
}

main:5
Thread-0:5
Thread-1:8

8、守护(daemon)线程

注意事项：

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
如，后台记录操作日志，监控内存，垃圾回收等待...

测试代码：

package pers.mobian.thread;

public class TestDaemonThread {
    public static void main(String[] args) {
        God god = new God();
        Thread thread = new Thread(god);

        //将God线程设置成守护线程，setDaemon的参数默认是false
        //守护线程按道理不会结束，但是用户线程结束以后，守护线程也会跟着结束，两者之间相差一个虚拟机的相应时间
        thread.setDaemon(true);
        thread.start();

        new Thread(new You()).start();
    }
}

//新建一个守护线程
class God implements Runnable {
    @Override
    public void run() {
        while (true){
            System.out.println("这是一个守护线程");
        }
    }
}

//新建一个用户线程
class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("这是一个用户线程");
        }
    }
}

执行结果：

这是一个守护线程
这是一个守护线程
这是一个用户线程
//共20个
这是一个用户线程
这是一个守护线程
//虚拟机停止的时间段打印的语句：这是一个守护线程
这是一个守护线程

4、线程同步（重点）

并发：同一个对象被多个线程同时操作

线程同不的安全性需要：队列+锁

1、synchronized(Obj){}

线程不安全的测试代码一：

//该测试证明了，Array是线程不安全的
package pers.mobian.thread;

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

public class TestUnsafeThread {
    public static void main(String[] args) {
        List<String> arr = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
               arr.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(arr);
        //打印添加以后的集合的长度
        System.out.println(arr.size());
    }
}

执行结果：

[Thread-0, Thread-2, Thread-6, Thread-5, Thread-4, Thread-3, Thread-7, Thread-1, Thread-13, Thread-14, Thread-12, Thread-15]
15

线程不安全的测试案例二：

package pers.mobian.thread;

//买票的不安全性
public class TestUnsafeThread2 {
    public static void main(String[] args) {
        BuyTickets buyTickets = new BuyTickets();
        new Thread(buyTickets,"我").start();
        new Thread(buyTickets,"你").start();
        new Thread(buyTickets,"他").start();

    }
}
class  BuyTickets implements Runnable {
    private  int tickets = 10;
    boolean flag = true;

    @Override
    public  void run() {
        while(flag) {
            //买票的方法体
            buy();
        }
    }
    //买票的方法
    private  void buy() {
        if(tickets <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+tickets--+"票");
    }
}

执行结果：

我买了第10票
我买了第7票
我买了第6票
我买了第5票
你买了第9票
他买了第8票
你买了第3票
我买了第4票
你买了第1票
他买了第2票
你买了第0票
我买了第-1票

总结：上述两个例子，都证明了线程在运行过程中的没有同不执行的问题，即所谓的线程不安全

案例一优化代码：

package pers.mobian.thread;

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

public class TestUnsafeThread {
    public static void main(String[] args) throws InterruptedException {
        List<String> arr = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                //有synchronized关键字包裹整个代码块
                synchronized (arr){
                    arr.add(Thread.currentThread().getName());
                }
            }).start();
        }
        //需要添加睡眠一秒钟，继而达到数据更加的明确
        Thread.sleep(1000);
        System.out.println(arr.size());       
    }
}

案例二优化代码：

private synchronized void buy()

总结：

补充：

CopyOnWriteArrayList集合是线程安全的，是一个底层是有锁的集合

package pers.mobian.thread;

import java.util.concurrent.CopyOnWriteArrayList;

public class TestGUCThread {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> arr = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                arr.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(arr.size());
    }
}

死锁：

多个线程各自占有一些共享资源，并且胡秀昂等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步款同时具有“两个以上对象的锁”时，就而可能会发生死锁的问题

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：与i个进程因请求资源而阻塞时，对已获得的资源保持不放
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程之间形成一种头尾想接的循环等待资源关系

总结：上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

测试代码：

package pers.mobian.thread;


//口红类
class Lipstick {

}

//镜子类
class Mirror {

}

//化妆类
class Makeup implements Runnable {

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    //选择先得到口红还是镜子的判定
    int choice;
    String name;

    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //互相获取对方资源的测试方法
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(name + "获得了口红");
                Thread.sleep(1000);
                synchronized (mirror) {
                    System.out.println(name + "获得了镜子");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(name + "获得了镜子");
                Thread.sleep(2000);
                synchronized (lipstick) {
                    System.out.println(name + "获得了口红");
                }
            }

        }
    }
}

public class TestLockThread {
    public static void main(String[] args) {
        Makeup m1 = new Makeup(1, "pan");
        new Thread(m1).start();
        Makeup m2 = new Makeup(0, "mobian");
        new Thread(m2).start();
    }
}

执行结果：

//由于他们都获取不到下一步的锁，多以出现了死锁的现象
pan获得了镜子
mobian获得了口红
    
//解决方式：第二次获得锁的代码块外提
    
//如：
else {
    synchronized (mirror) {
        System.out.println(name + "获得了镜子");
        Thread.sleep(2000);
    }
    synchronized (lipstick) {
            System.out.println(name + "获得了口红");
        }
}

2、Lock(锁)

测试代码：

package pers.mobian.thread;

import java.util.concurrent.locks.ReentrantLock;

public class TestLockThread2 {
    public static void main(String[] args) {
        BuyTickets b1 = new BuyTickets();

        new Thread(b1).start();
        new Thread(b1).start();
        new Thread(b1).start();
    }
}

//买票的案例
class BuyTickets implements Runnable {
    private int nums = 10;
    //定义的方式，模仿源码的写法
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //使用lock锁时，使用try{}finally{}语句，对相应的代码块进行相应的操作
            try {
                lock.lock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (nums <= 0) {
                    break;
                } else {
                    System.out.println(nums--);
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

执行结果：

//10-1的依次打印
10
9
8
7
6
5
4
3
2
1

补充：

5、线程通信问题

线程通信，问题分析：

Java提供了几个方法解决线程之间的通信问题：

方法名	作用
wait()	表示线程一直等待，直到其他线程同hi在，与sleep不同会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同不方法或者同不代码块中使用，否则会抛出异常lllegalMonitorStateException

解决方式一：

测试代码：

package pers.mobian.thread;

import java.util.zip.CheckedInputStream;

//管程法
public class TestPCThread {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Customer(container).start();
    }
}

//生产者
class Productor extends Thread {
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

//消费者
class Customer extends Thread {
    SynContainer container;

    public Customer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("消费了第" + container.pop().id + "只鸡");
        }
    }
}

//商品
class Chicken {
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区的
class SynContainer {
    //需要一个容器存放物品
    Chicken[] chickens = new Chicken[3];
    int count = 1;

    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //判断是否满
        if (count == chickens.length) {
            //通知消费者，生产产品
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，则放入
        chickens[count] = chicken;
        count++;

        //通知消费者
        this.notifyAll();

    }

    //消费者消耗产品
    public synchronized Chicken pop() {
        //判断物品是否为空
        if (count == 0) {
            //通知生产者生产商品
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果存在商品，则消费商品
        count--;
        Chicken chicken = chickens[count];

        this.notifyAll();
        return chicken;
    }
}

执行结果：

//达到了预期效果
生产了1只鸡
消费了第1只鸡
生产了2只鸡
消费了第2只鸡
生产了3只鸡
消费了第3只鸡
生产了4只鸡
消费了第4只鸡
生产了5只鸡
消费了第5只鸡
生产了6只鸡
消费了第6只鸡
生产了7只鸡
生产了8只鸡
生产了9只鸡
消费了第7只鸡
消费了第9只鸡
生产了10只鸡
消费了第10只鸡
消费了第8只鸡

解决方式二：

测试代码：

package pers.mobian.thread;

public class TestPCThread2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

//演员
class Player extends Thread {
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            if (i % 2 == 0) {
                this.tv.play("节目一");
            } else {
                this.tv.play("节目二");
            }
        }
    }
}

//观众(消费者)
class Watcher extends Thread {
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            tv.watch();
        }
    }
}

//节目
class TV {
    String voice;
    boolean flag = true;

    //表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了：" + voice);
        this.notifyAll();//
        this.voice = voice;
        this.flag = !this.flag;
    }


    //观看
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了：" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

执行结果：

演员表演了：节目一
观看了：节目一
演员表演了：节目二
观看了：节目二
演员表演了：节目一
观看了：节目一
演员表演了：节目二
观看了：节目二
演员表演了：节目一
观看了：节目一

线程池：

使用：

测试代码：

package pers.mobian.thread;

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

public class TestPoolThread {
    public static void main(String[] args) {
        //创建线程池,并且设置线程池的大小为2
        ExecutorService service = Executors.newFixedThreadPool(2);

        //Runnable接口的创建方式
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭线程
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

执行结果：

pool-1-thread-1
pool-1-thread-1
pool-1-thread-2

posted on 2020-01-19 16:09 默辨阅读(109) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

默辨