Java基础2线程

步致道

已于 2023-07-09 00:48:57 修改

阅读量72

点赞数

文章标签： java jvm 开发语言

于 2023-04-23 00:08:53 首次发布

本文链接：https://blog.csdn.net/zhangnx10000/article/details/129919797

版权

什么是线程？

线程就是独立的执行路径，是程序中执行的进程。

线程的特点

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

Thread类

继承的是Object类
调用start()方法开启多线程
调用普通方法和调用strat()方法的区别，start()会一起执行，而普通的方法只有一条执行路径
普通方法和start方法

Runnable接口

Runnable接口里面只有一个run方法，所以引用后要重写里面的run()方法，而且启动多线程的话要new一个Thread类调用start()进行启动。

Runnable和Thread类的区别

Callable接口

好处：
1.可以定义返回值，
2.可以抛出异常。

//Callable接口也是线程的一种，但是不常用，作为了解和补充
public class ThreadTestCallable implements Callable {
    private String name;
    private  String url;

    //构造函数
    public ThreadTestCallable(String name,String url){
        this.name = name;
        this.url = url;
    }
    //Callable函数重写call方法而不是run方法
    //下载图片线程的执行体
    @Override
    public Boolean call(){
        WebDownLoad webDownLoad = new WebDownLoad();
        webDownLoad.webDownLoad(name,url);
        System.out.println("下载的文件名为"+name);
        return true;
    }

    //可以抛出异常
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadTestCallable thread1 = new ThreadTestCallable("ta1.jpg","https://tenfei02.cfp.cn/creative/vcg/800/new/VCG211289012916.jpg");
        ThreadTestCallable thread2 = new ThreadTestCallable("ta2.jpg","https://tenfei02.cfp.cn/creative/vcg/800/new/VCG211289012916.jpg");
        ThreadTestCallable thread3 = new ThreadTestCallable("ta3.jpg","https://tenfei02.cfp.cn/creative/vcg/800/new/VCG211289012916.jpg");

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

        //提交执行
        Future<Boolean> r1 = ser.submit(thread1);
        Future<Boolean> r2 = ser.submit(thread2);
        Future<Boolean> r3 = ser.submit(thread3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //rs123可以返回call()结果,结果为true

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

Lamda 表达式

为什么使用lamda表达式？
1.避免内部的匿名类定义过多。
2.为了使得代码看上去更简洁。
3.去掉繁琐的代码，只留下核心逻辑。

什么是函数式接口？
任何接口，如果只包含了唯一一个抽象方法，那么他就是一个函数式接口。
对于函数式接口，我们可以通过lamda表达式来创建该接口的对象。

lamda表达式方法的使用
在这里插入图片描述
简化：
接口：

lamda知识点总结

静态代理

首先他需要有一个接口

然后需要一个角色

这个角色有些功能他是完成不了的，需要一个帮手。（哪些功能呢？）

接着在主函数中去实现他

总结：
真实对象和代理对象都要使用一个接口
代理对象要代理真实角色
好处：
代理对象可以做真实角色做不了的事情，而真实对象可以专注做自己的事情

线程的五大状态

在这里插入图片描述

监测线程的状态

在这里插入图片描述
JDK帮助文档的描述：

使用getState()方法获取state状态，程序详情：
在这里插入图片描述
结果：

线程方法

在这里插入图片描述

停止线程

在这里插入图片描述
run()是线程体，表示主要功能，当需要run()方法停止时，调用stop()方法停止。
该方法不建议使用。
什么叫自己停下来呢？
应该就是到达某种条件后不再执行了，而不是调用其他方法来停止。

线程休眠

线程休眠
在这里插入图片描述

线程礼让

在这里插入图片描述
程序：
礼让的程序
礼让成功：

礼让失败：

线程强制执行

程序：
强制执行结果：
在这里插入图片描述

线程的优先级

在这里插入图片描述
代码：

调用上面的方法写一个对象并给予优先级

结果：

可以看出线程3的优先级出现性能倒置，不过我目前不知道怎么解决，埋一个伏笔。

守护线程

在这里插入图片描述

代码：
守护线程的代码
结果：
在这里插入图片描述

这里守护线程在用户线程停止之后就停止了。
守护线程是使得用户线程不会在用户线程执行完之前终止。

线程同步

三大不安全案例

1.模拟抢票：
运行代码：

（这里有点奇怪的地方在于，如果按照狂老师的代码，结果就会出现-1，其代码如下）
在这里插入图片描述
结果：

如果不写buy，那么其结果则不会出现-1,代码：

结果：

但是！我很幸运的在尝试这么描写时，运行代码出现了错误，有两个人拿到了第十张票，这说明，如果分开写只是放大了犯错的概率，而不是说合在一起写不会发生。不过合在一起写没有出现-1，而分开写没有出现多个人抢一张票的概率（多个人抢一张票的事情前面狂老师有写过例子，但是没有具体细讲）。至于是因为数据量过小还是因为各有优劣导致出现这样的事情，还是需要继续学习吧。

2.模拟银行
创建账号类
在这里插入图片描述
模拟取钱
执行类：

结果：

3.不安全的线程
运行代码：
线程不安全
执行结果：

不安全的原因：两个线程同一瞬间操作了把两个数据添加到了同一个位置，那么其中一个数据就被覆盖掉了，那么就会造成数据的丢失。

同步方法及同步块

在这里插入图片描述
取票例子加入同步方法：

在这里插入图片描述
synchronized 锁使得同步线程只能挨个执行，这里是synchronized对象同步块可以锁任何对象，锁的对象是谁，括号里面就填谁，默认锁的是this,锁的对象应该是变化的量，增删改的变量

银行例子加入同步块：
在这里插入图片描述
不安全线程集合加入同步块：

JUC安全类型的集合

CopyOnWriteArrayList
它本身就是一个已经被写好的类：

不用再使用同步方法和同步块了。
但是当我将sleep()去掉的时候，结果就不是100了。
猜想：应该是因为循环没有执行完就是输出长度了，所以说长度不够长。当用sleep()将线程挂起后，他没有立即执行输出方法，for也加载完成了，所以长度就够了。

死锁问题

在这里插入图片描述
死锁代码示例（让线程相互占用对方下一步需要的资源导致死锁）：

class Car{}
class Gun{}
class Play extends Thread{
    static Car car = new Car();
    static Gun gun = new Gun();
    int choice;
    String name;
    Play(int choice,String name){
        this.choice = choice;
        this.name = name;
    }

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

    private void play() throws InterruptedException {
        if(choice == 0){
            synchronized (car){
                System.out.println(this.name+"拿到了车还想要枪");
                Thread.sleep(1000);
                synchronized (gun){
                    System.out.println(this.name+"拿到了车还拿到了枪");
                }
            }
        }else{
            synchronized (gun){
                System.out.println(this.name+"拿到了枪还想要车");
                Thread.sleep(2000);
                synchronized (car){
                    System.out.println(this.name+"拿到了枪还拿到了车");
                }
            }
        }
    }
}

结果（导致死锁，线程没有结束）：
在这里插入图片描述
修改之后（不再占用资源，使用后就把资源进行释放）：

class Car{}
class Gun{}
class Play extends Thread{
    static Car car = new Car();
    static Gun gun = new Gun();
    int choice;
    String name;
    Play(int choice,String name){
        this.choice = choice;
        this.name = name;
    }

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

    private void play() throws InterruptedException {
        if(choice == 0){
            synchronized (car){
                System.out.println(this.name+"拿到了车还想要枪");
                Thread.sleep(1000);
            }
            synchronized (gun){
                System.out.println(this.name+"拿到了车还拿到了枪");
            }
        }else{
            synchronized (gun){
                System.out.println(this.name+"拿到了枪还想要车");
                Thread.sleep(2000);
            }
            synchronized (car){
                System.out.println(this.name+"拿到了枪还拿到了车");
            }
        }
    }
}

结果：
在这里插入图片描述
运行代码：

public class DeadLock {
    public static void main(String[] args) {
        Play boy1 = new Play(0,"小明");
        Play boy2 = new Play(1,"小亮");
        boy1.start();
        boy2.start();
    }
}

Lock锁

未加锁之前：

public class Lock {
    public static void main(String[] args) {
        ThreadLock threadLock = new ThreadLock();
        new Thread(threadLock).start();
        new Thread(threadLock).start();
        new Thread(threadLock).start();
    }
}
class ThreadLock implements Runnable{
    int Tickets = 10;
    @Override
    public void run() {
        while (true){
            if(Tickets > 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Tickets--);
            }else {
                break;
            }
        }
    }
}

结果：
在这里插入图片描述
加锁部分：

class ThreadLock implements Runnable{
    int Tickets = 10;
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            lock.lock();
            while (true){
                if(Tickets > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Tickets--);
                }else {
                    break;
                }
            }
        }finally {
            lock.unlock();
        }

    }
}

结果：
在这里插入图片描述

这里弹幕说将线程休眠放在锁下面更好一些，可以模拟出多个人同时操作线程的情形，这样使得线程一下子跑完了，如果放在里面，虽然没有模拟环境，但显示出了其结果是一个一个走的，并不是在未加锁时三个三个的走。

lock与synchronized区别

生产者与消费者模式（问题）

在这里插入图片描述

线程通信的方法

在这里插入图片描述

解决方式：

在这里插入图片描述

总结：生产者生产，消费者消费，两者之间进行通信

方式1 管程法

例子生产鸡：
首先有鸡
鸡的类
然后有一个缓冲区，生产者和消费者在这里进行通信

class SynContainer{
    Chicken[] chickens = new Chicken[10];
    int count = 0;
    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--后，再拿到一只鸡，因为前面生产者是先赋值后++，等待存放下一只鸡
        //这里如果不先--的话，就什么都拿不到。
        count--;
        //这里的chicken就是拿到的那只鸡，即数组中某个元素给变量赋值
        Chicken chicken = chickens[count];
        //消费完了通知生产
        this.notifyAll();
        return chicken;
    }
}

然后有一个生产者负责做鸡
在这里插入图片描述
有一个消费者进行吃鸡

最后运行代码：

得出结果：

原本以为这次的结果是最值得商榷的，不过粘出来之后才发现是最理想的结果，那就放着吧（注意下标是从0开始）

方法2 信号灯法

信号灯法最明显的标志就是有一个信号灯

class TV{
    String program;
    boolean flag = true;//这就是信号灯
    public synchronized void play(String program){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了一个"+program);
        this.notifyAll();
        this.flag = !this.flag;
        this.program = program;

    }
    public synchronized void see(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了一个"+program);
        this.notifyAll();
        this.flag = !this.flag;
    }
}

接下来就是表演者和观众
表演者：

观众：

运行：

结果：
在这里插入图片描述
主要就是有一个信号灯使得生产者和消费者进行通信，从而使得生产者和消费者（可能）交替进行。

线程池

第二页

例子：

结果：

这里我误打误撞使用了另一个线程池，newCachedThreadPool，它的特点是它创建的线程如果在六十秒内未执行则会被移除。
狂神教的是这个：
newFixedThreadPool
结果是没什么变化的：

由此了解到线程池还有很多，接下来可以进行补充完善（单独开一篇）。

总结：
三种线程的启动方式：

public class TestThreeThread {
    public static void main(String[] args) {
        //一般线程的启动方式
        new ThreadNormal().start();
        //Runnable线程的启动方式
        new Thread(new ThreadRunnable()).start();
        //Callable启动方式 <Integer>是泛型约束，不加也行
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new ThreadCallable());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println("返回值："+integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class ThreadNormal extends Thread{
    @Override
    public void run() {
        System.out.println("Thread");
    }
}

class ThreadRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable");
    }
}
//callable方法继承了runnable方法，需要返回值
class ThreadCallable implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable");
        return 10000;
    }
}