java线程

最新推荐文章于 2025-02-28 23:24:24 发布
最新推荐文章于 2025-02-28 23:24:24 发布
阅读量47 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59023564/article/details/131886038
版权

1. 多线程

1.1、什么是进程?什么是线程?
1.进程是一一个应用程序(1个进程是一个软件)
线程是一一个进程中的执行场景/执行单元。
一个进程可以启动多个线程。

1.2、对于java程序来说，当在DOS命令窗口中输入:

java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负贲看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发,一个是垃圾回收线程，一个是执行main方法的主线程。

注意:
进程A和进程B的内存独立不共享。( 阿里巴巴和京东资源不会共享的! )
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。

1.3线程A和线程B呢?
在java语言中:线程A和线程B，堆内存和方法区内存共享。但是栈内存独立，一个线程一一个栈。
假设启动10个线程，会有10个栈空间，每个栈和每个栈之间,互不干扰，各自执行各自的，这就是多线程并发。
main方法结束只代表主线程结束了，其它线程可能还在执行。
1.4、java语言中，实现线程有两种方式，那两种方式呢?
java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。
第一种方式:骗写-一个类，直接继承java.lang.Thread,重写run方法。

//myThread.run(); //不会启动线程，不会分配新的分支栈。( 这种方式就是单线程。)
// start()方法的作用是:启动一个分支线程,在JVM中开辟-一个新的栈空间,这段代码任务完成之后,瞬间就结束了。
//这段代码的任务只是为了开启-一个新的栈空间，只要新的栈空间开出来, start()方法就结束了。线程就启动成功了。
//启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)。
// run方法在分支栈的栈底部, main方法在主栈的栈底部。run和main是平级的。

第一种方式:编写-一个类，直接继承java. lang . Thread,重写run方法。
定义线程类

public class MyThread01 {
    public static void main(String[] args) {
		//创建线程对象
        Mythread mythread=new Mythread();
        //开启新的栈空间
        mythread.start();
        for (int i = 0; i < 1000; i++) {

            System.out.println("主线程---->"+i);

        }
    }
}
class Mythread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<1000;i++){
            System.out.println("分支线程---->"+i);
        }

    }
}

第二种方式:编写-一个类，实现java.lang .Runnable接口，实现run方法。

//定义一个可运行的类


public class Mythread02Runnable {
    public static void main(String[] args) {
        //实现线程的第二种方式，编写一个类实现java.lang.Runnable接口。
        Thread thread=new Thread(new MyRunnable());
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程---->"+i);
        }
        
        //创建线程对象，采用匿名内部类方式。
        //这是通过一个没有名字的类, new出来的对象。
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("t---->"+i);

                }
            }
        });
        t.start();

    }

}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("分支线程---->"+i);
        }
    }
    //这并不是一个线程类,是一个可运行的类。它还不是一个线程。

}

2. 线程的生命周期

在这里插入图片描述

3. Tread线程的常用方法

  1. 怎么获取当前线程对象?
    Thread t = Thread.currentThread();
    返回值t就是当前线程。
  2. 获取线程对象的名字
    String name =线程对象.getName();
  3. 修改线程对象的名字
    线程对象. setName( "线程名字);
  4. 当线程没有设置名字的时候,默认的名字有什么规律? (了解一下)
    Thread-θ
    Thread-1
    Thread-2
    Thread-3

关于线程的sleep方法:
static void sleep(long millis)
1、静态方法: Thread.sleep(1000);
2、参数是毫秒
3、作用:让当前线程进入休眠,进入“阻塞状态”,放弃占有CPU时间片，让给其它线程使用。
这行代码出现在A线程中, A线程就会进入休眠。
这行代码出现在B线程中, B线程就会进入休眠。
4、Thread.sleep()方法，可以他到这种效果:
间隔特定的时间，去执行一段特定的代码,每隔多久执行一次。

public class Thread04Sleep {
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("----->"+i);
        }

    }
}

如何合理终止线程。

public class 合理终止线程 {
    public static void main(String[] args) {
        myrunnable r=new myrunnable();
        Thread thread=new Thread(r);
        thread.start();

        try {
            thread.sleep(1000*5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //终止线程
        r.flat=false;
    }
}
class myrunnable implements Runnable{
        //打一个布尔型的标志
    boolean flat=true;

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            if (flat){
                System.out.println(Thread.currentThread().getName()+"----->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }else {
                //终止线程
                // return就结束了，你在结束之前还有什么没保存的。
                //在这里可以保存呀。
                //save....
                //终止当前线程

                return ;
            }

        }

    }
}

1、(这部分内容属于了解)关于线程的调度

1.1、常见的线程调度模型有哪些?

抢占式调度模型:

那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。9java采用的就是抢占式调度模型。
均分式调度模型:
平均分配cPU时间片。每个线程占有的CPU时间片时间长度一样。平均分配，一 切平等。有一些编程语言，线程调度模型采用的是这种方式。

1.2、java中提供了哪些方法是和线程调度有关系的呢?

实例方法:
void setPriority (int newPriority)设置线程的优先级
int getPriority()获取线程优先级

最低优先级1

默认优先级是5

最高优先级10

静态方法:
static void yield()

让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从"运行状态”回到\就绪状态”。
注意:在回到就绪之后，有可能还会再次抢到。.

public class 线程优先级 {
    public static void main(String[] args) {
        Thread currentThread= Thread.currentThread();
        System.out.println("最高级优先级"+Thread.MAX_PRIORITY);//10
        System.out.println("最低级优先级"+Thread.MIN_PRIORITY);//1
        System.out.println("默认级优先级"+Thread.NORM_PRIORITY);//5


        System.out.println("主线程main的优先级"+currentThread.getPriority());
        currentThread.setPriority(10);
        System.out.println("改变后的线程main的优先级"+currentThread.getPriority());

        System.out.println(currentThread.getName()+"主线程默认优先级"+currentThread.getPriority());
        MyRunnable01 myRunnable01=new MyRunnable01();
        Thread thread = new Thread(myRunnable01);
        thread.setName("t");

        thread.setPriority(1);
        thread.start();
        //优先级高的，只是抢到的时间片比较多
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程默认优先级"+Thread.currentThread().getPriority());
        }
    }

}
class MyRunnable01 implements Runnable{

    @Override
    public void run() {

        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+"线程默认优先级"+Thread.currentThread().getPriority());
        }

    }
}

线程让位，当前线程暂停，回到就绪状态,让给其它线程。

静态方法: Thread.yield();

线程合并。

public class 线程合并 {
    public static void main(String[] args) {
        System.out.println("main begin");
        Thread thread=new Thread(new MyRunnable4());
        thread.setName("t");
        thread.start();
        try {
            thread.join();//thread线程将合并到当前线程中，当前线程受阻塞，thread线程执行直到结束
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("main over");


    }
}
 class MyRunnable4 implements Runnable{

     @Override
     public void run() {
         for (int i = 0; i < 1000; i++) {
             System.out.println(Thread.currentThread().getName()+"----->"+i);

         }
     }
 }

4. 关于多线程并发环境下，数据的安全问题。

4.1、 为什么这个是重点?
以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实现完了。这些代码我们都不需要编写。最重要的是:你要知道，你编写的程序需要放到-一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的。(重点: *****)

4.2、什么时候数据在多线程并发的环境下会存在安全问题呢?
三个条件:
条件1:多线程并发。
条件2:有共享数据。
条件3:共享数据有修改的行为。

4.3、怎么解决线程安全问题呢?
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在
线程安全问题，怎么解决这个问题?

线程排队执行。(不能并发)。
用排队执行解决线程安全问题。
这种机制被称为:线程同步机制。
专业术语叫做:线程同步，实际上就是线程不能并发了，线程必须排队执行。

怎么解决线程安全问题呀?
使用"线程同步机制"。
线程同步就是线程排队了，线程排队了就会牺牲-一部分效率，没办法，数据安全
第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

异步编程模型:
线程t1和线程t2，各自执行各自的，t1不管t2， t2不管t1,
谁也不需要等谁，这种编程模型叫做:异步编程模型。
其实就是:多线程并发(效率较高。)
异步就是并发。

同步编程模型:
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
结束，或者说在t2线程执行的时候，必须等待t1线程执行结束,
两个线程之间发生了等待关系，这就是同步编程模型。
效率较低。线程排队执行。
同步就是排队。|

package 线程.线程安全;

public class Account {

    private String accountNumber;    //账号

    private double balance;   //余额
    public Account(){

    }

    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    public void setAccountNumber(String accountNumber) {
        this.accountNumber = accountNumber;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //取款的方法
    public void withdraw(double money){
        /*以下这几行代码必须是线程排队的，不能并发。
        一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
        线程同步机制的语法是:
        synchronized(){
        线程同步代码块。
        }
       synchronized后面小括号中传的这个“数据”是相当关键的。
        这个数据必须是多线程共享的数据。才能达到多线程排队。
        ()中写什么?
                那要看你想让哪些线程同步。
        假设t1、t2、t3、t4、t5 ,有5个线程,
                你只希望t1 t2 t3排队, t4 t5不需要排队。怎么办?
                你一定要在()中写-个t1 t2 t3共享的对象。而这个
        对象对于t4 t5来说不是共享的。*/

        /*这里的共享对象是:账户对象。
        账户对象是共享的，那么this就是账户对象吧! ! !
        不一定是this ,这里只要是多线程共享的那个对象就行。
        以下代码的执行原理?
        1、假设t1和t2线程并发,开始执行以下代码的时候,肯定有一个先一个后。
        2、假设t1先执行了,遇到了synchronized ,这个时候自动找“后面共享对象”的对象锁,
        找到之后，并占有这把锁,然后执行同步代码块中的程序,在程序执行过程中一直都是
        占有这把锁的。直到同步代码块代码结束,这把锁才会释放。
        3、假设t1 已经占有这把锁,此时t2也遇到synchronized关键字,也会去占有后面
        共享对象的这把锁,结果这把锁被t1占有, t2只能在同步代码块外面等待t1的结束,
        直到t1把同步代码块执行结束了, t1会归还这把锁，此时t2终于等到这把锁,然后
        t2占有这把锁之后,进入同步代码块执行程序。

        */
        //synchronized (obj) {
        //synchronized ("abc") { // "abc" 在字符串常量池当中。
        //synchronized (null) { //报错:空指针。
        //synchronized (obj2) { //这样编写就不安全了。因为obj2 不是共享对象。
        synchronized (this) {
           //取款之前的
           double before = this.getBalance();
           //取款之后的
           double after;
           after=before-money;
           //模拟一下网络延迟，100%出问题
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
           //更新余额
           //思考:t1执行到这里了,但还没有来得及执行这行代码, t2线程进来vithdraw方法了。此时一定出问题。
           this.setBalance(after);
       }


    }
}

//账户类

package 线程.线程安全;

public class AccountThread extends Thread{
    private Account act;//两个线程必须共享一个对象
    public AccountThread(Account act){
        this.act=act;
    }
    //run方法表示执行取款操作
    @Override
    public void run() {
        double money=5000;


        act.withdraw(money);

        System.out.println(Thread.currentThread().getName()+"对账号"+act.getAccountNumber()+"取款"+money+"余额为"+act.getBalance());


    }
}

测试类

package 线程.线程安全;

public class Test {
    public static void main(String[] args) {
        //创建一个账户
        Account act=new Account("act01",10000);
        Thread t1=new AccountThread(act);
        Thread t2=new AccountThread(act);
        t1.setName("t1");
        t2.setName("t2");
        //启动线程取款
        t1.start();
        t2.start();


    }
}

线程同步机制的语法是:

synchronized(){
//线程同步代码块。
}

synchronized后面小括号中传的这个“数据”是相当关键的。
这个数据必须是多线程共享的数据。才能达到多线程排队。|
*/

3、Java中有三大变量?重要的内容。
实例变量:在堆中。
静态变量:在方法区。
局部变量:在栈中。

以上三三大变量中:
局部变量永远都不会存在线程安全问题。
因为局部变量不共享。(一个线程一个栈。)
局部变量在栈中。所以局部变量永远都不会共享。

实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量:不会有线程安全问题。
成员变量:可能会有线程安全问题。

如果使用局部变量的话:
建议使用: stringBuilder.
因为局部变量不存在线程安全问题。选择stringBuilder。
stringBuffer效率比较低。

synchronized有三种写法:
第一种:同步代码块
灵活

synchronized (线程共享对象) {
同步代码块;
}

第二种:在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。

第三种:在静态方法上使用synchronized
表示找类锁。
一个类的类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。
对象锁: 1个对象1把锁，100个 对象100把锁。
类锁:100个对象，也可能只是1把类锁。
类锁、对象锁

//面试题: doOther方法执行的时候需要等待doSome方法的结束吗?
//需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把。

public class 类锁 {
    public static void main(String[] args) throws InterruptedException {
        MyClassTest mc1 = new MyClassTest();
        MyClassTest mc2 = new MyClassTest();

        Thread t1=new MyThread05(mc1);
        Thread t2=new MyThread05(mc2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        Thread.sleep(1000);
        t2.start();

    }
}
class MyClassTest{

    // svnchronized出现在静杰方法上是羽类锁。
    public static synchronized  void doSome(){
        System.out.println("dosome begin");

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

            throw new RuntimeException(e);
        }
        System.out.println("dosome over");

    }
    public static synchronized  void doOther(){
        System.out.println("doOther begin");
        System.out.println("doOther over");

    }
}

class MyThread05 extends Thread{
    private MyClassTest mc;

    public MyThread05(MyClassTest mc) {
        this.mc = mc;
    }



    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("t1")){
            mc.doSome();
        }if (Thread.currentThread().getName().equals("t2")){
            mc.doOther();
        }

    }
}

死锁

package 线程.死锁;

public class Deadlock {
    public static void main(String[] args) {
        Object o1 =new Object();
        Object o2=new Object();


        Thread t1=new MyThread(o1,o2);
        Thread t2=new MyThread1(o1,o2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();

    }
}
class MyThread extends Thread{
    private  Object o1;
    private Object o2;

    public MyThread(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o1){

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("死锁1");
            synchronized (o2){

                }
        }


    }
}
class MyThread1 extends Thread{
    private  Object o1;
    private Object o2;

    public MyThread1(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run() {
        synchronized (o2){

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("死锁2");
            synchronized (o1){

            }
        }


    }
}

聊一聊，我们以后开发中应该怎么解决线程安全问题?
是一上来就选择线程同步吗? synchroni zed
不是，synchroni zed会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择.
线程同步机制。
第一种方案:尽量使用局部变量代替“实例变量和静态变量"。
第二种方案:如果必须是实例变量，那么可以考虑创建多个对象，这样
实例变量的内存就不共享了。(-一个线程对应1个对象，100个线程对应100个对象,
对象不共享，就没有数据安全问题了。)
第三种方案:如果不能使用局部变量，对象也不能创建多个，这个时候
就只能选择synchronized了。线程同步机制。

线程这块还有那些内容呢?列举一下

  1. 守护线程
    java语言中线程分为两大类:
    一类是:用户线程
    一类是:守护线程(后台线程)
    其中具有代表性的就是:垃圾回收线程(守护线程)。

守护线程的特点:
一般守护线程是一个死循环，所有的用户线程只要结束,
守护线程自动结束。
注意:主线程main方法是一个用户线程。
守护线程用在什么地方呢?
守护线程用在什么地方呢?

每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，没到00:00的时候就备份一次。所有的用户线程.如果结束了，守护线程自动退出，没有必要进行数据备份了

  1. 定时器
    定时器的作用:
    间隔特定的时间，执行特定的程序。
    每周要进行银行账户的总账操作。
    每天要进行数据的备份操作。
    在实际的开发中，每隔多久执行一.段特定的程序，这种需求是很常见的,
    那么在java中其实可以采用多种方式实现:
    可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
    任务。这种方式是最原始的定时器。(比较low)

在java的类库中已经写好了一个定时器: java.util.Timer,可以直接拿来用.
不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
定时任务的。
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架,
这个框架只要进行简单的配置，就可以完成定时器的任务。

public class 定时器 {
    public static void main(String[] args) throws ParseException {
        //创建定时器对象
        Timer timer=new Timer();
        //Timer timer1=new Timer(true);守护线程

        //指定定时任务
        //timer.schedule(定时任务，第一次执行的时间，间隔多久执行一次);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date first=sdf.parse("2023-07-31 21:04:33");
        timer.schedule(new LogTimerTask(),first,1000*3);

		 /* 匿名内部类的方式
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String StrTime=sdf.format(new Date());
                System.out.println(StrTime+"完成一次数据备份");
            }
        },first,1000*3);)
         */


    }
}
//编写一个定时任务类
//假设这是一个记录日志俄定时任务
class LogTimerTask extends TimerTask{

    @Override
    public void run() {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String StrTime=sdf.format(new Date());
        System.out.println(StrTime+"完成一次数据备份");
    }
}
  1. 实现线程的第三种方式: FultureTask方式，实现Callable接口。( JDK8新特性。)
    这种方式实现的线程可以获取线程的返回值。
    之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void.

系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
会有一个执行结果，我们怎么能拿到这个执行结果呢?
使用第三种方式:实现Callable接口方式。
代码：

/*
    实现线程的第三种方式:
    实现callable接口
    这种方式的优点:可以获取到线程的执行结果。
    这种方式的缺点:效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。


* */

public class 实现Callable接口 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第一步创建一个未来任务类对象
        //参数非常重要，需要给一个callable接口实现对象
        FutureTask task=new FutureTask<>(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                System.out.println("call method begin");
                int a=10;
                Thread.sleep(1000*3);
                int b=5;
                return a+b;//自动装箱
            }
        });
        Thread thread=new Thread(task);
        thread.start();
         //在主线程中获取thread的返回值结果
        Object object=task.get();
        System.out.println("线程执行结果："+object);
        System.out.println("线程阻塞");
        // main万法这里的程序要想执行必须等待get()万法的结束
        //而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        //另一个线程执行是需要时间的。|

        System.out.println();
    }
}
  1. 关于object类中的wait和notify方法。( 生产者和消费者模式! )
    第一: wait和notify方 法不是线程对象的方法，是java中任何- 一个java对象
    都有的方法，因为这两个方式是object类中自带的。
    wait方法和notify方法不是通过线程对象调用,
    不是这样的: t.wait()， 也不是这样的: t.notify() . .不对。

第二: wait()方法作用 ?

Oject= o new Object() ;
o.wait();

表示:
让正在o对象上活动的线程进入等待状态，无期限等待,直到被唤醒为止。
o.wait();方法的调用，会让"当前线程( 正在o对象上活动的线程) "进入等待状态。|
在这里插入图片描述

    1、使用wait方法和notify方法实现“生产者和消费者模式”
    2、什么是“生产者和消费者模式”?
        生产线程负责生产,消费线程负责消费。
        生产线程和消费线程要达到均衡。
        这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。
    3、wait 和notify方法不是线程对象的方法,是普通java对象都有的方法。
    4、wait方法和notify方法建立在线程同步的基础之.上。因为多线程要同时操作-一个仓库。有线程安全问题。
    5. wait方法作用:o. wait()让正在o对象上活动的线程t进入等待状态,并且释放掉t线程之前占有的o对象的锁。
    6、模拟这样一个需求:
        仓库我们采用ist集合。
        List集合中假设只能存储1个元素。
        1个元素就表示仓库满了。
        如果List集合中元素个数是0，就表示仓库空了。
        保证list集合中永远都是最多存储1个元素。
        必须做到这种效果:生产1个消费1个。

在这里插入图片描述


public class 生产者消费者模式 {
    public static void main(String[] args) {
        List list=new ArrayList();
        Thread t1=new Thread(new producer(list));
        Thread t2=new Thread(new consumer(list));
        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();
    }
}
class producer  implements Runnable{
    private List list;

    public producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true){
            synchronized (list){
                if (list.size()>0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                //程序能够执行到这里说明仓库是空的，需要生产商品
                Object o=new Object();
                list.add(o);
                System.out.println(Thread.currentThread().getName()+"-------->"+o);
                list.notify();//唤醒消费者线程消费
            }



        }
    }
}
class consumer implements Runnable{
    private List list;

    public consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true){
            synchronized (list){
                if(list.size()==0){
                    try {
                        //仓库已经空了，消费者线程进入等待
                        // 需要释放掉list集合的锁
                        list.wait();//释放list集合的锁，使代码进入消费者线程
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                //程序能够执行这里说明仓库里面有商品，可以进行消费
               Object obj= list.remove(0);
                System.out.println(Thread.currentThread().getName()+"-------->"+obj);
                list.notify();//唤醒生产者线程生产
            }
        }

    }
}
Java线程
m0_56188609的博客
02-22 3228
两个线程同时运行均要使用CPU，While(ture)为死循环，两个线程均需要不断使用CPU，而两个线程大量使用CPU会造成CPU占用率达到100%，其他代码、操作系统其他程序就会暂停卡住。因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码（从使用CPU到不适用CPU称之为线程的一次上下文切换）当然它的底层是否由多个核心对这两个线程并行执行还是一个核心对它们并发处理，包括打印的前后顺序是不由我们控制的。（快照：只能查看某一刻） 查看某个 Java 进程（PID）的所有线程状态。
02Java线程模型
爱丹丹的博客
11-20 1555
线程有哪几种实现方式？Java线程与操作系统线程之间又有什么关系呢？
Java线程系列详解
wang_yong_hui_1234的博客
04-15 5345
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
探索Java线程副本技术：深入理解与实践ThreadLocal
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
05-01 5万+
ThreadLocal作为Java线程副本技术的核心实现，为多线程编程提供了强大的线程隔离能力。深入理解其工作原理、掌握正确的使用方法、关注潜在问题及最佳实践，将有助于开发者在复杂并发场景下编写高效、安全、易于维护的代码。
【线程】Java线程操作
telasi2004的博客
11-23 1540
讲述了线程的启动、终止、等待操作，还有线程的各种状态。
Java 线程
BusyMonkey
12-17 770
目录 1、线程状态 1.1、Blocked 1.2、Time_waited/Waiting 2、主线程和子线程 2.1、start和run 2.2、主线程结束，子线程继续 2.3、主线程等待子线程结束后结束 2.4、主线程结束，子线程结束 2.5、守护线程 3、sleep和wait 3.1、sleep 3.2、wait 4、线程相关方法 4.1、join 4.2、yi...
JAVA线程
kittydzl的博客
04-23 154
线程-多线程 CPU执行代码都是一条一条顺序执行的，但是，即使是单核cpu，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。 类似的，操作系统轮流让多个任务交替执行，例如，让浏览器执行0.001秒，让QQ执行0.001秒，再让音乐播放器执行0.001秒，在人看来，CPU就是在同时执行多个任务。 即使是多核CPU，因为通常任务的数量远远多于CPU的核数，所以任...
Spring Boot 实战篇（四）：实现用户登录与注册功能
m0_74824823的博客
02-27 1142
在构建 Web 应用程序时，用户登录与注册功能是常见且重要的部分。以下将详细介绍在 Spring Boot 项目中实现用户登录与注册功能的步骤，并附上相应的代码示例。
java练习（40）
IIIIIIlllii的博客
02-26 527
ps：题目来自力扣二叉树的后序遍历给你一棵二叉树的根节点root，返回其节点值的。
【GESP】C++二级真题 luogu-B4037 [GESP202409 二级] 小杨的 N 字矩阵
CoderCoding的博客
02-28 282
【GESP】C++二级真题 luogu-B4037 [GESP202409 二级] 小杨的 N 字矩阵 | OneCoder。GESP二级真题，多层循环和分支练习，难度★✮☆☆☆。GESP二级真题，多层循环和分支练习，难度★✮☆☆☆。
JVM内存模型详解：各个区域的作用与原理
最新发布
秃头之旅
02-28 826
方法区（Method Area）堆（Heap）栈（Stack）本地方法栈（Native Method Stack）程序计数器（Program Counter Register）这些区域共同协作，确保Java程序的正常运行。下面我们将逐一介绍这些区域。JVM内存模型是Java程序运行的基础，理解各个内存区域的作用和原理对于编写高效、稳定的Java程序至关重要。方法区：存储类信息、常量、静态变量等。堆：存储对象实例和数组，是垃圾回收的主要区域。栈：存储局部变量和方法调用，线程私有。本地方法栈。
计算机毕业设计SpringBoot+Vue.js作业管理系统(源码+文档+PPT+讲解)
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
02-28 817
计算机毕业设计SpringBoot+Vue.js作业管理系统(源码+文档+PPT+讲解)
SpringBoot AOP 源码解析
qq_45090949的博客
02-27 994
定义两个 Aspect, 一个 Around Aspect, 一个是分离(Before, After, AfterReturn, AfterThrowing)的 Aspect/***/@Slf4j@Component@Aspect@Slf4j@Component@Aspect/*** 实现了 SmartInstantiationAwareBeanPostProcessor, 所以在 Bean 的生命周期中会执行该类的。
PHP实现国密SM4算法,银行系统加密算法，JAVA和PHP可相互转换（附完整源码）
billy_moda的博客
02-27 308
PHP实现国密SM4算法,银行系统加密算法，JAVA和PHP可相互转换
6.指针学习
weixin_45752674的博客
02-27 426
Pointer Learning Records.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值