多线程(基于狂神的视频笔记)

 本文章是观看狂神课程用于记录ppt没有实质内容,详细请移步

https://www.bilibili.com/video/BV1V4411p7EF?p=23

多任务

 多线程

 程序 进程 与线程

 gc线程  垃圾回收器

创建线程的三种方式

 1.继承Thread类

 

/** 
* @Description: 创建线程方式一:继承 Thread类,重写run()方法
* @Param:    注意  :  线程开启不一定立即执行,由cpu调度执行
* @return:  
* @Author: 
* @Date: 2022/5/8 
*/ 
public class TestThread1 extends Thread{

    //  run()  方法线程体
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看java代码--"+i);
        }
    }


    public static void main(String[] args) {
        //main线程  主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start()方法开启线程
        testThread1.start();

        for (int i = 0; i < 50; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

 从运行结果可以看到两个线程是同时执行的,交替执行

 

 2.实现Runnable接口

/**
* @Description: 创建线程方式二:实现Runnable接口,重写run方法,执行线程需要丢入runnable接口的实现类,调用start方法
* @Param:
* @return:
* @Author:
* @Date: 2022/5/14
*/
public class TestThread3 implements Runnable {
    //  run()  方法线程体
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看java代码--"+i);
        }
    }


    public static void main(String[] args) {
        //main线程  主线程

        //创建Runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象,通过线程对象来开启我们的线程,代理
        Thread thread = new Thread(testThread3);

        //new Thread(testThread3).start();  上面的简写

        //调用start()方法开启线程
        thread.start();

        for (int i = 0; i < 50; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

继承Thread的话只能继承一个类，实现runable的话还可以继承别的类

/** 
* @Description:模拟龟兔赛跑
* @Param:  
* @return:  
* @Author: 
* @Date: 2022/5/15 
*/ 
public class TestThread5 implements Runnable {
    //胜利者
    private static String winner;

    @Override
    public void run() {

        for (int i = 0; i <=100; i++) {
            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag=gameOver(i);
            //如果比赛结束了就停止程序
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

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

    public static void main(String[] args) {

        //创建实现runnable接口的对象
        TestThread5 testThread5=new TestThread5();

        new Thread(testThread5,"兔子").start();
        new Thread(testThread5,"乌龟").start();

    }
}

3.实现Callable接口

 Lamda表达式

 

 

用了Lamda只用关心它的核心代码,方法和接口都去掉只留下方法内容

 

//总结:
//Lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。//前提是接口为函数式接口
//多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号，

 线程状态

 

 

线程停止 

 

 线程休眠

 模拟网络延时:放大问题的发生性

线程礼让

 线程强制执行

 观测线程状态

/** 
* @Description: 观察测试线程的状态
* @Param:  
* @return:  
* @Author: 
* @Date: 2022/5/15 
*/ 
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        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);  //NEW

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

        while (state != Thread.State.TERMINATED) {//只要线程不终止,就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);  //输出状态

        }
    }
}

 线程优先级

 守护线程

 线程同步机制

 

 线程同步需要 队列+锁    解决线程同步的安全性

 

 

 

 

         锁的对象是变化的量(需要增删改的对象)

死锁

多个线程互相抱着对方需要的资源,然后形成僵持

 

 Lock锁

import java.util.concurrent.locks.ReentrantLock;

/**
* @Description: 测试lock锁   显示的定义锁
* @Param:  
* @return:  
* @Author: 
* @Date: 2022/5/16 
*/ 
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2=new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }

}


class TestLock2 implements Runnable {
    int ticketNums = 10;

    //定义lock锁
    private final ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        while (true) {//票ticketNums要变化了给它加锁
            try {
                lock.lock();//加锁

                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
            }
            } finally { //解锁放到finally里
                lock.unlock();//解锁
            }
        }
    }
}

 

 

 

 线程协作

 

 

 

 

 

 线程池