【笔记】Java多线程基础知识汇总

最新推荐文章于 2024-05-21 10:23:42 发布

CookieskyXDU

最新推荐文章于 2024-05-21 10:23:42 发布

阅读量136

点赞数

分类专栏： Java 文章标签： java eclipse 面试

本文链接：https://blog.csdn.net/m0_52739647/article/details/119948189

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java多线程基础

前言

基于狂神Java多线程的总结，在整理视频内容的同时，归纳整理了进程最基础、最简单的代码实现与状态相关的函数使用。

如果想要快速了解多线程框架结构，请直接至最后一节查看总结。

简介

Process和Thread

程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。

一个进程可以包含有多个线程（如视频中同时听到声音、看到图像，还可以看弹幕）

一个进程至少有一个线程，否则无存在的意义。

线程：CPU调度和执行的单位。

注意：很多多线程是模拟出来，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，cpu只能执行一个代码，因为切换很快，所以就有同时执行的错觉。

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

线程创建

方法一-Thread

继承Thread类

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

    }

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

        //创建一个线程对象
        Demo01 demo01 = new Demo01();
        //调用start（）方法开启线程
        demo01.start();
        //start（）是同时运行的，每次随机
        //demo01.run();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习---"+i);
        }
    }
}

方法二-Runnable(常用)

public class Race implements Runnable {

    @Override
    public void run() {

   //不同进程的有所区别的进行活动
     if(Thread.currentThread().getName().equals("兔子")) {}
	//主体

        }
    }
//主进程，固定写法用来将几个线程开启
    public static void main(String[] args) {
    	//这里是类名
        Race race = new Race();

        //启动方式，标记进程名字便于区分
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }
}

//外部类创建
public class ThreadPriority {
    //主线程
    public static void main(String[] args) {
        MyPriority myPriority = new MyPriority();
        //用了代理
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);

        t1.start();
        t2.start();
  
   
    }



}

class MyPriority implements Runnable{
    @Override
    public void run() {}
}

不难发现以上两者方法都是在重写run()方法实现多线程，不同的是runnbale更加灵活，可以方便同一个对象被多个线程使用

一般规范写法

MyPriority myPriority = new MyPriority();
       
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);

        t1.start();
        t2.start();

简化写法：（匿名）

    Race race = new Race();
    //启动方式，标记进程名字便于区分
    new Thread(race,"兔子").start();
    new Thread(race,"乌龟").start();

方法三-Callable

可以定义返回值

可以抛出异常

//implements Callable<Boolean>注意有返回值
public class TestCallable implements Callable<Boolean> {
  
    //执行体，重写call()方法，注意是Boolean
    @Override
    public Boolean call() {
       //里面是主执行体

    }
//加上异常抛出
    public static void main(String[] args) throws ExecutionException,InterruptedException{
        //new 一个class，只有一个class才能new
        TestCallable t1 = new TestCallable("https://img-home.csdnimg.cn/images/20210818045531.png","photo4");
        TestCallable t2 = new TestCallable("https://csdnimg.cn/medal/qixiebiaobing1@240.png","photo3");

        //创建执行服务：
        ExecutorService ser = Executors.newFixedThreadPool(2);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        //获取结果
        boolean rs1 =r1.get();
        boolean rs2 =r2.get();
        System.out.println(rs1);
        System.out.println(rs2);
        //关闭服务
        ser.shutdown();



    }
}
//在进程中主程序更多是用于启动进程的

区别

继承Thread类

子类继承Thread类具备多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性

实现Runnable接口

实现Runnable接口具备多线程能力
启动线程：new Thread(子类对象).start()
推荐使用：避免单继承局限性，方便同一个对象被多个线程使用

实现Callable接口

优点：1.可以定义返回值；2.能抛出异常
缺点：相比而言较为麻烦

底部原理-静态代理

线程的底部原理是代理

举例：结婚

//真实对象和代理对象都需要实现同一个接口
//代理对象要代理真实角色
//代理对象可以做很多真实对象做不了的事情，真实对象可以更加专注

//主程序中新建you类，创建WeddingCompany(传入you类)、使用方法
public class StacticProxy {

    public static void main(String[] args) {
        You you = new You();
        WeddingCompany weddingCompany = new WeddingCompany(you);
        weddingCompany.HappyMarry();
        //简化代码
        //new WeddingCompany(new You()).HappyMarry();
        //new Thread(()-> System.out.println("I love You")).start();
    }
}

interface Marry{

    void HappyMarry();
}

//真实对象
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了开心");
    }
}
//代理角色
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 after() {
        System.out.println("结婚后，收钱");
    }

    private void before() {
        System.out.println("结婚前，布置现场");
    }
}

//这个接口是整个流程的总体过程
//下述公司和个人两个类分别implements了这个接口，并重写了里面的方法
//you类的重写只专注与结婚，公司的重写专注于前后过程
//公司类中还添加了WeddingCompany(Marry target)，用来调用真实对象

代理：

相当于一个接口下的两个实现类，一个中调用构造器传入另一个类作为参数对象，在自己的方法构造里包含参数类中的方法，再加上一些其他的执行语句，从而实现真实对象的更加专注

结合线程来看：

Thread便使用了静态代理

lamda表达式

函数式接口：如果只包含唯一一个抽象方法，就是一个函数式接口

接口使用

正常使用

public class TestLambda2 {
    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(2);

        }

    }



interface Ilove{
    void love(int a);
}
class Love implements Ilove{
    @Override
    public void love(int a) {
        System.out.println("i love you"+a);
    }
}
//接口的使用

先建立接口（在主class外）
使用一个类完善这个接口
在主进程中

接口名 自定义 = new 类名();
自定义.方法名;

静态内部类

public class TestLambda2 {
 static class 类名 implements 接口名{
    @Override
    public void 方法名(int a) {
        System.out.println("i love you"+a);
    }
}





    public static void main(String[] args) {
        接口名 自定义 = new 类名();
		自定义.方法名;

        }

    }



interface 接口名{
    void 方法名(int a);
}

//接口的使用

static class加在class里面

同时interface接口还在class外

局部内部类

public class TestLambda2 {
 





    public static void main(String[] args) {
    	class 类名 implements 接口名{
    	@Override
    	public void 方法名(int a) {
   		System.out.println("i love you"+a);
    		}
    	}	
    
    
    
    
        接口名 自定义 = new 类名();
		自定义.方法名;

        }

    }



interface 接口名{
    void 方法名(int a);
}

//接口的使用

直接class放入主程序里面

加在new上面

匿名内部类

public class TestLambda2 {
 





    public static void main(String[] args) {
    	接口名 自定义 = new 接口名(){
    	@Override
    	public void 方法名(int a) {
   		System.out.println("i love you"+a);
    		}
    	}	
    自定义.方法名;

        }

    }



interface 接口名{
    void 方法名(int a);
}

//接口的使用

改的是主进程里面的构造处，将构造和接口的类化合成一步了，类被匿名

lambda表达式

函数接口必须只有一个方法

public class TestLambda2 {
 





    public static void main(String[] args) {
    	接口名 自定义 = ()-> {
   		System.out.println("i love you"+a);
    	}	
    	自定义.方法名;

        }

    }



interface 接口名{
    void 方法名(int a);
}

//接口的使用

只剩下一个核心方法过程

lambda表达式简化

参数类型可以省略
参数括号可以省略//多个参数也可以去掉参数类型，要去都去必须加上括号
去掉花括号//多行代码不行

接口名 自定义 = a-> System.out.println("i love you"+a);

结合多线程

//Runnable源码

//public interface Runnable{

//public abstract void run();

//}
//符合lambda表达式

new Thread(()->{ ... }).start();

线程状态

新生状态
就绪状态
运行状态
阻塞状态
死亡状态

在这里插入图片描述

线程停止

stop()/destroy()已弃用
建议线程正常停止
建议使用标志位，设置标志位

public class TestStop implements Runnable{
private boolean flag = true;
    @Override
    public void run() {
        while (flag){}
        }
    //设置公开方法停止线程，转换标识位
    public void stop(){
        this.flag= false;
    }
   //使用if语句判断调用stop即可
    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
            if(i){
                threadStop.stop();
            }
        }
        }

线程休眠

1s=1000ms
模拟网络延迟//方法问题发生性
倒计时
每个对象都有一个锁，sleep不会释放锁

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

//模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
//        try {
//            tenDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        //打印系统当前时间
        Date startTime = new Date(System.currentTimeMillis());  //获取系统当前时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());  //更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }
}

线程礼让

cpu重新调度，礼让不一定成功

public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();

    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();   //礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}

线程强制执行

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);

        //主线程
        for (int i = 0; i < 1000; i++) {
            if(i == 200){
                thread.start();
                thread.join(); //插队
            }
            System.out.println("main"+i);
            
        }
    }
}

观测线程状态

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();   //Run

        while(state != Thread.State.TERMINATED){  //只要线程不停止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();    //更新线程状态
            System.out.println(state);   //输出状态
            
            //thread.start();   报错，因为已经死亡的线程不能再启动
        }
    }
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围从1~10.
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;

线程调度器按优先级执行，还需要cpu选择

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

//        t5.setPriority(-1);   //Exception in thread "main" java.lang.IllegalArgumentException
//        t5.start();
//
//        t6.setPriority(11);   //Exception in thread "main" java.lang.IllegalArgumentException
//        t6.start();

    }

}

class MyPriority implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守护线程

用户线程与守护线程
- 虚拟机必须确保用户线程执行完毕-main()
- 虚拟机不用等待守护线程执行完毕-gc()
  - 后台记录操作日志
  - 监控内存
  - 垃圾回收等待

//举例上帝守护你
public class TestDaemon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);   //默认false表示是用户线程，正常的线程都是用户线程

        thread.start();  //上帝守护线程启动

        new Thread(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 < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
        System.out.println("=====GoodBye World!======");
    }
}

总结

//首先上述可大致分为三类
//第一类，创建进程类对象，实例化Thread类结合代理之后，直接使用 
TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

//之后直接进行调用

thread.start(); 

thread.join();

thread.stop(); 

thread.setPriority(XXX);

thread.setDaemon(true);   *//默认false表示是用户线程，正常的线程都是用户线程*



//第二类，程序中直接调用属于Thread中的方法

Thread.yield();

Thread.sleep(1000);




//第三类：观测状态，
//同类需要先创建对象进程对象，Thread对象，
//不同的是还需要Thread.State对象，后调用方法thread.getState()查询状态，如果需要显示打印即可

TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

Thread.State state = thread.getState();

state = thread.getState();

线程同步（synchronized）

并发：同一个对象被多个线程同时操作
- 抢票
- 两个银行同时取钱
多线程访问同一对象，排队等待机制，进入线程等待池
队列和锁
- 保证线程安全
- 每个对象都有一把锁
- 损失性能，性能倒置

不安全案例

(1)买票

//线程不安全 有负数
public class UnsafeBuyTicket  implements  Runnable{
    //票数
    private int ticketNums = 10;
    boolean flag = true;  //外部停止方法

    @Override
    public void run() {
        while(flag){
           buy();
        }
    }
    
    public void  buy(){
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums-- +"票");
    }

    public static void main(String[] args) {
        UnsafeBuyTicket ticket = new UnsafeBuyTicket();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }

}

(2)不安全的银行

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing wo = new Drawing(account,100,"wo");

        you.start();
        wo.start();
    }
}

//账户
class  Account{
    int money; //余额
    String name;  //卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;  //账户
    int drawingMoney;  //取了多少钱
    int nowMoney;   //现在手里有多少钱

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //卡内余额 = 余额 - 取的钱
        account.money = account.money - drawingMoney;
        //手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱："+nowMoney);
    }
}

(3)不安全的集合

public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}
//输出：9999

同步方法

//关键字，相当于锁了方法的对象本身this
synchronized
//在你解决并发问题的函数前加上即可

同步块

synchronized(锁的对象){代码}
//锁的对象，需要增删改的
//出块自动释放

并发JUC

可以实现线程同步

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> copy = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{

                    copy.add(Thread.currentThread().getName());


            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(copy.size());
    }
}
//输出：10000

基本使用如上，这里将涉及另一部分Java的JUC并发编程，在这里就不再展开。

死锁

各自占用一些共享资源，并且相互等待其他线程占有的资源才能运行，导致两个或者多个线程都在等待对方

//死锁：多个线程互相抱着对方需要的资源
public class DeadLock {

    public static void main(String[] args) {
        Makeup m1 = new Makeup(0,"小黑");
        Makeup m2 = new Makeup(1,"小白");

        m1.start();
        m2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makeup extends Thread{

    //需要的资源只有一份，用static来保证只有一份
    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(this.name+"获得口红的锁");
                Thread.sleep(1000);

                synchronized (mirror){  //一秒钟后想获得镜子的锁
                    System.out.println(this.name+"获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){  //获得镜子的锁
                System.out.println(this.name+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick) {  //两秒钟后想获得口红的锁
                    System.out.println(this.name + "获得口红的锁");
                }
            }
        }
    }

}

Lock

通过显示定义同步锁对象（Lock）来实现同步

ReentrantLock类实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁。

class A implements Runnable{
    private  final ReentrantLock lock =new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        try {
				......
            }
        }
        finally{
        lock.unlock();
        }
    }

synchronized与Lock对比

◆Lock是显式锁(手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
◆Lock只有代码块锁，synchronized有代码块锁和方法锁
◆使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
◆优先使用顺序:
Lock >同步代码块(已经进入了方法体，分配了相应资源) >同步方法(在方法体之外)

线程协作、通信

1.线程通信

（1）应用场景:生产者和消费者问题

假设仓库中只能存放- -件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.
如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止.
如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待，直到仓库中再次放入产品为止.

（2）分析：

这是一个线程同步问题,生产者和消费者共享同- -个资源,并且生产者和消费者之间相互依赖,互为条件.
对于生产者,没有生产产品之前,要通知消费者等待.而生产了产品之后又需要马上通知消费者消费
对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费.
在生产者消费者问题中,仅有synchronized是不够的
synchronized可阻止并发更新同一个共享资源，实现了同步
synchronized不能用来实现不同线程之间的消息传递(通信)

（3）解决方式：

并发协作模型—生产者消费者模式

管程法

建立缓存区

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

    public Productor(SynContainer container) {
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了第"+i+"只鸡");
        }
    }
}

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

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

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

}

//产品
class Chicken{
    int id;  //产品编号
    public Chicken(int id){
        this.id = id;
    }
}

//缓冲区
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--;
       Chicken chicken = chickens[count];

        //可以通知生产者消费了
        this.notifyAll();

       return chicken;
    }
}

(代码不是很严谨，存在先消费后生产的问题)

信号灯法

flag管理

//生产者--演员
class Player extends Thread{
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; 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 < 20; i++) {
            tv.watch();
        }
    }
}

//产品--节目
class TV{
    //演员表演，观众等待  T
    //观众观看，演员等待  F
    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;
    }

}

线程池

背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
便于线程管理
corePoolSize: 核心池的大小
maximumPoolSize:最大线程数
keepAliveTime: 线程没有任务时最多保持多长时间后会终止

  public class TestPool {
    
        public static void main(String[] args) {
            //1.创建服务，创建线程池
            ExecutorService service = Executors.newFixedThreadPool(10);  //参数为线程池大小
    
            //执行
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
            service.execute(new MyThread());
    
            //2.关闭连接
            service.shutdown();
        }
    
    }
    
    class MyThread implements Runnable{
    
        @Override
        public void run() {
                System.out.println(Thread.currentThread().getName());
        }
    }

总结

线程创建

//继承Thread类
public class Demo01 extends Thread {
    @Override
    public void run() {//重写run方法线程执行主体}
    
    public static void main(String[] args) {

        Demo01 demo01 = new Demo01();  
        demo01.start();
        //添加主进程内容
        }
    }
}



//Runnable

public class Race implements Runnable {

    @Override
    public void run() {//重写run方法线程执行主体}
    
    public static void main(String[] args) {
       
        Thread t1 = new Thread(XXX);
        Thread t2 = new Thread(XXX);
        t1.start();
        t2.start();

    }
}
//这里都是直接在一个类中重写了run方法并启动了线程，当然也可以在其他类中可以重写run()，然后在main下开启执行

简化表示

//匿名类
Race XXX = new Race();
new Thread(XXX,"NAME1").start();


//lambda表达式

new Thread(()->{ ... }).start();

线程状态相关方法

//第一类，创建进程类对象，实例化Thread类结合代理之后，直接使用 
TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

//之后直接进行调用

thread.start(); 

thread.join();

thread.stop(); 

thread.setPriority(XXX);

thread.setDaemon(true);   *//默认false表示是用户线程，正常的线程都是用户线程*



//第二类，程序中直接调用属于Thread中的方法

Thread.yield();

Thread.sleep(1000);




//第三类：观测状态，
//同类需要先创建对象进程对象，Thread对象，
//不同的是还需要Thread.State对象，后调用方法thread.getState()查询状态，如果需要显示打印即可

TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

Thread.State state = thread.getState();

state = thread.getState();

其他细节

//获取线程名称
Thread.currentThread().getName()

//获取线程优先级
Thread.currentThread().getPriority()

//不同进程的有所区别的进行
//在run()方法中加入一个判断
if(Thread.currentThread().getName().equals("NAME")) {}


(String[] args) {

        Demo01 demo01 = new Demo01();  
        demo01.start();
        //添加主进程内容
        }
    }
}



//Runnable

public class Race implements Runnable {

    @Override
    public void run() {//重写run方法线程执行主体}
    
    public static void main(String[] args) {
       
        Thread t1 = new Thread(XXX);
        Thread t2 = new Thread(XXX);
        t1.start();
        t2.start();

    }
}
//这里都是直接在一个类中重写了run方法并启动了线程，当然也可以在其他类中可以重写run()，然后在main下开启执行

简化表示

//匿名类
Race XXX = new Race();
new Thread(XXX,"NAME1").start();


//lambda表达式

new Thread(()->{ ... }).start();

线程状态相关方法

//第一类，创建进程类对象，实例化Thread类结合代理之后，直接使用 
TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

//之后直接进行调用

thread.start(); 

thread.join();

thread.stop(); 

thread.setPriority(XXX);

thread.setDaemon(true);   *//默认false表示是用户线程，正常的线程都是用户线程*



//第二类，程序中直接调用属于Thread中的方法

Thread.yield();

Thread.sleep(1000);




//第三类：观测状态，
//同类需要先创建对象进程对象，Thread对象，
//不同的是还需要Thread.State对象，后调用方法thread.getState()查询状态，如果需要显示打印即可

TestClass testclass = new TestClass();

Thread thread = new Thread(testclass);

Thread.State state = thread.getState();

state = thread.getState();

其他细节

//获取线程名称
Thread.currentThread().getName()

//获取线程优先级
Thread.currentThread().getPriority()

//不同进程的有所区别的进行
//在run()方法中加入一个判断
if(Thread.currentThread().getName().equals("NAME")) {}

参考资料：B站-狂神Java多线程

CookieskyXDU

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【笔记】Java多线程基础知识汇总

Java多线程基础前言基于狂神Java多线程的总结，在整理视频内容的同时，归纳整理了进程最基础、最简单的代码实现与状态相关的函数使用。如果想要快速了解多线程框架结构，请直接点击此处查看总结简介Process和Thread程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。一个进程可以包含有多个线程（如视频中同时听到声音、看到图像，还可以看弹幕）一个进程至少有一个线程，否则无存在的意义。线程：CPU
复制链接

扫一扫