***记录学习005(Java多线程)***

最新推荐文章于 2024-03-27 14:44:09 发布
最新推荐文章于 2024-03-27 14:44:09 发布
阅读量122 收藏
点赞数
分类专栏： Java笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46001400/article/details/109554242
版权

Java多线程

文章目录


在这里插入图片描述

在这里插入图片描述

1.继承Thread类

在这里插入图片描述

示例

package www.lin.processandthread;


//创建线程方式一：继承Thread类，重写run()方法，调用start()开启线程
//总结：注意，线程开启不一定立即执行，由cpu调度执行

import www.linrui.Test;

public class TestThread1 extends Thread{
    @Override
    //run方法线程体
    public void run() {
        for (int i = 0; i < 1000; i++){
            System.out.println("这是run方法for循环---" + i);
        }
    }


    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 thread1 = new TestThread1();
        //调用start()方法开启线程
        thread1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("这是主函数for循环---" + i);
        }
    }
}

1.1下载图片

在这里插入图片描述

示例

package www.lin.processandthread;

import org.apache.commons.io.FileUtils;

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


//练习Thread，实现多线程同步下载图片
public class TestThread2 extends Thread{
    private String url;  //保存图片地址
    private String name;    //保存的文件名

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

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为:" + name);

    }


    public static void main(String[] args) {
        TestThread2 testThread1 = new TestThread2("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTL00AP0001NOS.jpg","1.jpg");
        TestThread2 testThread2 = new TestThread2("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTM00AP0001NOS.jpg","2.jpg");
        TestThread2 testThread3 = new TestThread2("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTN00AP0001NOS.jpg","3.jpg");

        testThread1.start();
        testThread2.start();
        testThread3.start();

    }
}


//下载器
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异常，downloader方法出现问题");
        }

    }

}

2. 实现Runnable接口（推荐使用）

在这里插入图片描述

示例

package www.lin.processandthread;

//创建线程方式二：实现runnable接口，重写run()方法，执行线程需要丢入runnable接口实现类，调用start()方法,Thread也是实现runnable接口。
//推荐使用runnable接口
public class TestThread3 implements Runnable {
    @Override
    //run方法线程体
    public void run() {
        for (int i = 0; i < 1000; i++){
            System.out.println("这是run方法for循环---" + i);
        }
    }


    public static void main(String[] args) {

        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();

        //创建线程对象，通过线程对象来开启我们的线程，代理
//        Thread thread = new Thread();
//        thread.start();
        new Thread(testThread3).start();


        for (int i = 0; i < 2000; i++) {
            System.out.println("这是主函数for循环---" + i);
        }
    }
}

在这里插入图片描述

3.实现Callable接口(了解即可)

在这里插入图片描述

示例

package www.lin.processandthread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * 创建线程方式三：实现Callable接口
 *
 * 好处
 * 1.可以定义返回值
 * 2.可以抛出异常
 */
public class TestCallable implements Callable<Boolean> {
    private String url;  //保存图片地址
    private String name;    //保存的文件名

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

    @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 testCallable1 = new TestCallable("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTL00AP0001NOS.jpg","1.jpg");
        TestCallable testCallable2 = new TestCallable("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTM00AP0001NOS.jpg","2.jpg");
        TestCallable testCallable3 = new TestCallable("http://pic-bucket.ws.126.net/photo/0001/2020-10-31/FQ939DTN00AP0001NOS.jpg","3.jpg");

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

        //提交执行
        Future<Boolean> r1 = service.submit(testCallable1);
        Future<Boolean> r2 = service.submit(testCallable2);
        Future<Boolean> r3 = service.submit(testCallable3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r1.get();
        boolean rs3 = r1.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);

        //关闭服务
        service.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异常，downloader方法出现问题");
            }

        }

    }
}

4.Lamda表达式

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

无参函数式接口

package www.lin.processandthread;

/**
 * 推导Lambda表达式
 */
public class TestLambda {
    //3.静态内部类
   static class Mines2 implements Mine{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }


    public static void main(String[] args) {
        Mine mine = new Mines();
        mine.lambda();

        mine = new Mines2();
        mine.lambda();


        //4.局部内部类
        class Mines3 implements Mine{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }

        mine = new Mines3();
        mine.lambda();

        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        mine = new Mine() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };

        mine.lambda();

        //6.用lambda简化
        mine = () ->{
            System.out.println("i like lambda5");
        };
        mine.lambda();


    }
}

//1.定义一个函数式接口
interface Mine{
    void lambda();
}

//2.实现类
class Mines implements Mine{
    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

带参函数式接口

package www.lin.processandthread;

public class TestLambda2 {



    public static void main(String[] args) {
        Ilike like = null;

        //1.lambda表达式简化
         like = (int a,int b)->{
            System.out.println("i like you-->" + a + "-->" + b);
        };

        //简化1.参数类型
        like = (a,b) ->{
            System.out.println("i like you-->" + a + "-->" + b);
        };

//        //简化2.简化括号
//        like = a ->{
//                System.out.println("i like you-->" + a);
//    };
//
//        //简化3.去掉花括号
//        like = a ->System.out.println("i like you-->" + a);



        like.like(520,521);

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




    }

}

interface Ilike{
    void like(int a,int b);
}

总结：

1.lambda表达式只能有一行代码的情况下才能简化为一行代码，如果有多行，那么就用代码块包裹。

2.表达式的前提是：接口为函数式接口（只能有一个函数）

3.多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

5.静态代理

在这里插入图片描述

示例

package www.lin.processandthread;


//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处
    // 代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();    //你要结婚

        new Thread(()-> System.out.println("我爱你！")).start();

        new WeddingCompany(new You()).HappyMarry();

//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
    }

}

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("结婚前，布置现场！");
    }


}

6.线程的状态

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

6.1线程停止

在这里插入图片描述

示例

package www.lin.processandthread;

//测试线程停止
//1.建议线程正常停止--->利用次数，不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法

public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run....Thread" + i++);
        }
    }

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }


    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if(i == 900){
                //调用stop方法切换标志位，让线程停止
                testStop.flag = false;
                System.out.println("线程停止了!");
            }
        }


    }
}

6.2 线程休眠

在这里插入图片描述

示例

package www.lin.processandthread;


import www.lin.gui.snakegame.Data;

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

public class TestSleep2 {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //打印当前系统时间
        Date date = new Date(System.currentTimeMillis());  //获取系统当前时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
                date = 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;
            }
        }
    }
}

6.3 线程礼让

在这里插入图片描述

示例

package www.lin.processandthread;

//测试礼让线程
//礼让不一定成功，看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() + "线程开始执行！");
    }
}

6.4 join

在这里插入图片描述

示例

package www.lin.processandthread;

//测试join方法   可理解为插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP来了" + i);
        }
    }


    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();


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

    }
}

6.5.线程的优先级

在这里插入图片描述

示例

package www.lin.processandthread;

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);

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

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

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

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

        t5.setPriority(8);
        t5.start();


    }
}

class MyPriority implements Runnable{

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

6.6 守护线程

在这里插入图片描述

示例

package www.lin.processandthread;

//测试守护线程
//上帝保佑着你
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You1 you1 = new You1();

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

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

        new Thread(you1).start(); //你  用户线程启动...


    }

}

//上帝
class God implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("上帝守护着你");
        }
    }
}



//你
class You1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 365; i++) {
            System.out.println("你一生开心地活着");
        }
        System.out.println("=====goodbye world=====");
    }
}

7.线程同步(重难点)

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

在这里插入图片描述

线程不安全的三个例子

不安全取钱

package www.lin.processandthread.syn;

//不安全取钱
//银行取钱
public class TestUnsafeBank {
    public static void main(String args[]){
        Account account = new Account(100,"创业基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing me = new Drawing(account,100,"我");

        you.start();
        me.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 nowMoney;
    int drawingMoney;

    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(3000);
        } 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);
    }
}

不安全买票

package www.lin.processandthread.syn;


//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"小明").start();
        new Thread(buyTicket,"小红").start();
        new Thread(buyTicket,"黄牛").start();
    }

}
class BuyTicket implements Runnable{

    private int ticketNumbers = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){       //  买票
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        if (ticketNumbers <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNumbers-- + "张票！");
    }

}

不安全集合

package www.lin.processandthread.syn;

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

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
               list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }
}

在这里插入图片描述

同步方法的弊端：

方法里面需要修改的内容才需要锁，锁的太多，浪费资源

在这里插入图片描述

synchronized：取钱

package www.lin.processandthread.syn;

//不安全取钱
//银行取钱
public class TestUnsafeBank {
    public static void main(String args[]){
        Account account = new Account(100,"创业基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing me = new Drawing(account,100,"我");

        you.start();
        me.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 nowMoney;
    int drawingMoney;

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

    }

    @Override
    public void run() {
        //锁的对象是变化的量，需要增删改的对象
        synchronized (account){
            if (account.money - drawingMoney < 0){      //判断有没有钱
            System.out.println(Thread.currentThread().getName() + "钱不够，取不了！");
            return;
        }
            try {
                Thread.sleep(3000);
            } 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);
        }

    }

}

synchronized：安全买票

package www.lin.processandthread.syn;


//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"小明").start();
        new Thread(buyTicket,"小红").start();
        new Thread(buyTicket,"黄牛").start();
    }

}
class BuyTicket implements Runnable{

    private int ticketNumbers = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){       //  买票
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized 同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {
        if (ticketNumbers <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNumbers-- + "张票！");
    }

}

synchronized：安全集合

package www.lin.processandthread.syn;

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

//不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        for (int i = 0; i < 10000; i++) {

            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }

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

        System.out.println(list.size());
    }
}

JUC安全集合

package www.lin.processandthread.syn;

import java.util.concurrent.CopyOnWriteArrayList; //并发包

//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        System.out.println(list.size());
    }
}

8.Lock锁

在这里插入图片描述

在这里插入图片描述

示例

package www.lin.processandthread.lock;

import java.util.concurrent.locks.ReentrantLock;

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 ticketNumbers = 10;

    //定义一个lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();    //加锁
                if (ticketNumbers > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNumbers--);
                }else {
                    break;
                }
            }finally {
                    lock.unlock();
                }
            }
        }
    }

8.1synchronized与lock对比

在这里插入图片描述

9.线程协作

在这里插入图片描述

示例

在这里插入图片描述

package www.lin.processandthread.lock;

//测试：生产者消费者模型--> 利用缓存区解决：管程法

//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
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;

    }

}

示例

在这里插入图片描述

package www.lin.processandthread.lock;

//测试：生产者消费者问题： 信号灯法，标志位解决
public class TestPC2 {
    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 < 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;


    }
}

在这里插入图片描述

在这里插入图片描述

示例

package www.lin.processandthread.lock;

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

//测试线程池
public class TesPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool  参数为：线程池大小
        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());
    }
}

10.总结创建

package www.lin.processandthread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//回顾总结线程的创建
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask<Integer> FutureTask = new FutureTask<Integer>(new MyTread3());
        new Thread(FutureTask).start();

        try {
            Integer integer = FutureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

//1.继承Thread类
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.实现Callable接口
class MyTread3 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}

学习摘自狂神说

在这里插入图片描述

雪习
关注
专栏目录
java多线程学习记录.rar
06-14
在本文中，我们将深入探讨Java多线程的相关知识点，这些内容来源于"java多线程学习记录"的文档。 1. **线程的概念与创建** - 线程是操作系统调度的基本单位，每个线程都有自己的程序计数器、栈、局部变量等，它们...
Java实验6多线程.doc
05-02
在Java编程中，多线程是一项...通过这个实验，学生不仅能够掌握Java多线程的基本概念，还能了解到如何将多线程应用于实际问题中，比如网络聊天应用程序。这对于进一步学习Java的并发编程和大型系统设计是非常有益的。
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3442
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
学习-java多线程
weixin_38822255的博客
12-08 978
通过其他线程调用interrupted（），打断睡眠(会抛interrupted异常)*如果非守护线程都结束，守护线程也强制结束（如果子线程是守护线程，主线程结束他也结束）*正常：java要等待所有线程结束才会结束，（不然主线程结束 子线程一样执行）优先级（1-10）默认5-（cup空闲的时候 几乎没有用）（线程状态：runing变runable(就绪)）记录每个线程的执行到哪里-记录当前线程的状态。是线程用的，（后进先出）（执行完就会释放）记录当前线程的状态等信息（局部变量，等）
Java多线程之深入学习线程池(Executor)
qq15035899256的博客
07-23 1154
本文是Java多线程的学习，认识了线程池的概念和作用，以及线程池的原理，如何自己实现线程池。了解了四种功能线程的用法。
Java多线程（超详解）
m0_52896041的博客
10-26 1万+
Java多线程（超详解）
【Java基础】多线程学习
qq_45291280的博客
02-02 1152
多线程学习
clientThread.rar_java 多线程_java 聊天
09-19
1. **Java多线程**：在Java中，多线程通过创建线程对象来实现。主要有两种方式，一是继承`Thread`类，二是实现`Runnable`接口。`Thread`类是所有线程的基类，而`Runnable`接口则为那些不希望继承`Thread`的类提供了...
xy.rar_Java 下载器_java 多线程下载
09-22
3. **多线程**：Java的`java.lang.Thread`类或者`java.util.concurrent`包中的`ExecutorService`和`Future`接口可以用来实现多线程下载。每个线程负责下载文件的一个部分。 4. **缓冲区**：为了提高效率，通常会...
net.rar_java 聊天_java 通讯 多线程_白板
09-23
2. **多线程**： 标签中的“java_通讯_多线程”暗示了项目使用多线程来处理并发通信。在Java中，多线程允许程序同时执行多个任务，提高效率。例如，`Sender.java`可能是一个用于发送消息的线程，而`MessageInput....
基于ssm的理发店会员管理系统设计与实现.docx
最新发布
09-14
基于ssm的理发店会员管理系统设计与实现.docx
Home-credit海外贷款信贷产品源码/线上贷款产品大全/贷款平台软件源码/海外借贷平台
09-14
测试环境：Linux系统CentOS7.6、宝塔、PHP7.3、MySQL5.6，根目录public，伪静态laravel5，开启ssl证书 语言：中文简体、英文 laravel框架的程序有点多，这个团队估计主要就是搞laravel开发的，基本上全是这个框架。。。 前端：修改网站的默认文档 index.html 为第一个， index.php 改成第二个 ，或者前端访问 index.html，是编译后的 数据库修改：根目录下面（不是public目录）的 .env 文件
数字听诊器设计-课程设计报告-基于MATLAB
09-14
数字听诊器设计-课程设计报告-基于MATLAB
python-env-manager.vsix
09-14
python-env-manager.vsix
快速入门Java并发编程与多线程实战
Java进阶课程之并发编程快速入门与多线程实战项目包括了CPU调度算法原理、线程安全问题分析、Callable与FutureTask模式手写以及并发队列日志框架实战案例等内容。在这门课程中，学员将深入了解到多线程技术的基本...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值