多线程

最新推荐文章于 2025-05-08 15:35:05 发布
最新推荐文章于 2025-05-08 15:35:05 发布
阅读量690 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44101129/article/details/112688063
版权

多线程

文章目录

在这里插入图片描述

线程开启的三种方式：

继承Thread类和实现Runnable接口（重点）、实现callable接口（了解）

继承Thread：
package pers.lwx.Thread;

/**
 * @program: study
 * @description: 开启线程
 * 1.创建线程的方式一：继承Thread类，重写run方法，调用start开启线程
 * 2.注意：线程开启不一立即执行，由cpu调度执行
 * @author: codelwx
 * @create: 2021-01-06 11:37
 **/
public class ThreadDemo extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for(int i = 0;i <= 200;i++){
            System.out.println("我是线程！");
        }
    }
    //main主线程
    public static void main(String[] args) {
        //创建一个线程对象
        ThreadDemo td = new ThreadDemo();
        //调用start()方法开启线程
        td.start();
        for(int j  = 0;j <= 2000;j++){
            System.out.println("我是方法体");
        }
    }
}
实现Runnable接口
package pers.lwx.Thread;

/**
 * @program: study
 * @description: 开启线程：
 * 1.开启线程方式二：实现Runnable接口,重写run方法，调用start方法开启线程
 * @author: codelwx
 * @create: 2021-01-11 14:48
 **/
public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <= 200; i++) {
            System.out.println("我是线程！");
        }
    }

    //main主线程
    public static void main(String[] args) {
        //创建实例对象
        RunnableDemo runnableDemo = new RunnableDemo();
        //创建线程对象，通过线程对象开启线程，实现代理
        //Thread td = new Thread(runnableDemo);
        //调用start()方法开启线程
        //td.start();
        new Thread(runnableDemo).start();
        for (int j = 0; j <= 2000; j++) {
            System.out.println("我是方法体");
        }
    }
}
小结

在这里插入图片描述

实现callable接口

在这里插入图片描述

实现Callable

package pers.lwx.Thread;

import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * @program: study
 * @description: 实现callable接口
 * @author: codelwx
 * @create: 2021-01-11 17:14
 **/
public class callableDemo implements Callable {
    private String url;//下载路径
    private String name;//下载文件名
    public callableDemo(String url,String name){
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() {
        WebDownloader01 wdl = new WebDownloader01();
        wdl.webDownloadFile(url,name);
        System.out.println("当前下载图片名称："+name);
        return true;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadDownloadFile thread01 = new ThreadDownloadFile("https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9KZExrRUk5c1pmZmVuSTJXM085enpzaWJVUldLWmRLS25qbTVxcmliaWFvRllnbUNXeTQxU2ljV1JzdERwaWNKdHZuaWJQNU5zaWM0VUJZSlhESGxpYzg5U0NwZmFRLzY0MA?x-oss-process=image/format,png","a1.jpg");
        ThreadDownloadFile thread02 = new ThreadDownloadFile("https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9KZExrRUk5c1pmZmVuSTJXM085enpzaWJVUldLWmRLS24ydGRlVlFDaGM1bFR5b1NNZkJ0bmJ3ZVlGZEhuZXE3UUZqa3JKZlp4aWJmMHlpYjdRMXF1VWNmdy82NDA?x-oss-process=image/format,png","a2.jpg");
        ThreadDownloadFile thread03 = new ThreadDownloadFile("https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9KZExrRUk5c1pmZmVuSTJXM085enpzaWJVUldLWmRLS25RS2liY3Q3ZGlhaWFrUG5rcE5EaWNGZ0hhVGx6bmNNMmphWmcxaWJnSlVwN0VhdGpQakdSZGljaWF0ZGNRLzY0MA?x-oss-process=image/format,png","a3.jpg");
        //创建执行服务
        ExecutorService exeser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = (Future<Boolean>) exeser.submit(thread01);
        Future<Boolean> r2 = (Future<Boolean>) exeser.submit(thread02);
        Future<Boolean> r3 = (Future<Boolean>) exeser.submit(thread03);
        //获取结果
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        exeser.shutdown();
    }
}
class WebDownloader01{
    public void webDownloadFile(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，webDownloader方法出现问题");
        }
    }
}

静态代理模式：

package pers.lwx.other;

/**
 * @program: study
 * @description: 静态代理模式对比线程
 * @author: codelwx
 * @create: 2021-01-11 18:10
 **/
public class StaticProxy {
    public static void main(String[] args) {
        new Thread(()-> System.out.println("我爱你")).start();
        WiddingMarry widdingMarry = new WiddingMarry(new you());
        widdingMarry.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色
class you implements Marry{

    @Override
    public void HappyMarry() {
        System.out.println("新婚快乐");
    }
}
//代理对象，代理完成结婚
class WiddingMarry implements Marry{
    private Marry target;

    public WiddingMarry(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("结婚前收定金");
    }
}

Lamda表达式

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

package pers.lwx.Lamda;

/**
 * @program: study
 * @description: lamda表达式
 * @author: codelwx
 * @create: 2021-01-11 19:01
 **/
public class LamdaDemo {
    //静态内部类
//    static class Like implements ILike {
//        @Override
//        public void love(int a) {
//            System.out.println("我爱你："+a);
//        }
//    }

    public static void main(String[] args) {
        //局部内部类
//        class Like implements ILike {
//            @Override
//            public void love(int a) {
//                System.out.println("我爱你：" + a);
//            }
//        }
        //匿名内部类
//        ILike ilike = new ILike() {
//            @Override
//            public void love(int a) {
//                System.out.println("我爱你：" + a);
//            }
//        };
//        ilike.love(5);
        //lamda表达式:简化
        ILike ilike = (int a) -> {
            System.out.println("我爱你：" + a);
        };
        ilike.love(5);
        //简化参数类型
        ILike ilike1 = (a) -> {
            System.out.println("我爱你：" + a);
        };
        ilike1.love(6);
        //简化括号
        ILike ilike2 = a -> {
            System.out.println("我爱你：" + a);
        };
        ilike2.love(7);
        //去掉花括号
        ILike ilike3 = a -> System.out.println("我爱你：" + a);
        ilike3.love(7);
        //总结：1.lamda表达式只有表达一行时可以去掉花括号
        //2.前提是接口为函数式接口
        //3.多个参数去掉参数类型时要一同去掉

    }


}

interface ILike {
    void love(int a);
}
//外部类
//class Like implements ILike {
//    @Override
//    public void love(int a) {
//
//    }
//}

线程状态：

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

停止线程：

在这里插入图片描述

package pers.lwx.Thread;

/**
 * @program: study
 * @description: 停止线程
 * @author: codelwx
 * @create: 2021-01-11 20:14
 **/
public class StopThread implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run..Thread:"+i++);
        }
    }
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        StopThread stopThread = new StopThread();
        new Thread(stopThread).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main:"+i);
            if(i == 900){
                stopThread.stop();
                System.out.println("线程停止了");
            }
        }
    }
}
sleep

在这里插入图片描述

package pers.lwx.ThreadState;

/**
 * @program: study
 * @description: 模拟网络延迟:放大问题的发生性
 * @author: codelwx
 * @create: 2021-01-11 20:34
 **/
public class SleepDemo01 implements Runnable {
    private int ticketNum = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "：抢的第" + ticketNum--);
        }
    }

    public static void main(String[] args) {
        SleepDemo01 tickets = new SleepDemo01();
        new Thread(tickets, "小明").start();
        new Thread(tickets, "老师").start();
        new Thread(tickets, "黄牛").start();
    }
}

package pers.lwx.ThreadState;

/**
 * @program: study
 * @description: 倒计时
 * @author: codelwx
 * @create: 2021-01-11 20:36
 **/
public class SleepDemo02 implements Runnable {
    @Override
    public void run() {
        int i = 10;
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i--);
            if (i <= 0) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        SleepDemo02 sleepDemo02 = new SleepDemo02();
        new Thread(sleepDemo02).start();
    }
}

package pers.lwx.ThreadState;

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

/**
 * @program: study
 * @description: 打印当前时间
 * @author: codelwx
 * @create: 2021-01-11 20:41
 **/
public class SleepDemo03{
    public static void main(String[] args) throws InterruptedException {
        Date date = new Date(System.currentTimeMillis());
        while(true){
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
            Thread.sleep(1000);
            date = new Date(System.currentTimeMillis());
        }
    }
}
yield

在这里插入图片描述

join

在这里插入图片描述

package pers.lwx.ThreadState;

/**
 * @program: study
 * @description: join阻塞测试
 * @author: codelwx
 * @create: 2021-01-12 14:46
 **/
public class JoinDemo implements Runnable {
    public static void main(String[] args) throws InterruptedException {
        JoinDemo joinDemo = new JoinDemo();
        Thread thread = new Thread(joinDemo);

        for (int i = 0; i < 100; i++) {
            if (i == 50) {
                thread.start();
                thread.join();
            }
            System.out.println("main:" + i);
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("vip占用" + i);
        }
    }
}

观测线程状态

在这里插入图片描述

package pers.lwx.Thread;

import static javafx.scene.input.KeyCode.T;

/**
 * @program: study
 * @description: 观测线程状态
 * @author: codelwx
 * @create: 2021-01-12 15:08
 **/
public class StateDemo {
    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(10);
            state = thread.getState();
            System.out.println(state);//输出线程状态
        }

    }
}

线程优先级

在这里插入图片描述

package pers.lwx.Thread;

/**
 * @program: study
 * @description: 线程优先级
 * @author: codelwx
 * @create: 2021-01-12 15:29
 **/
public class ThreadPriorityDemo {
    public static void main(String[] args) {
        //主线程信息
        System.out.println(Thread.currentThread().getName()+"-->+"+Thread.currentThread().getPriority());
        ThreadPriority threadPriority = new ThreadPriority();
        Thread t1 = new Thread(threadPriority, "1");
        Thread t2 = new Thread(threadPriority, "2");
        Thread t3 = new Thread(threadPriority, "3");
        Thread t4 = new Thread(threadPriority, "4");
        Thread t5 = new Thread(threadPriority, "5");
        Thread t6 = new Thread(threadPriority, "6");


        //设置线程优先级
        t1.setPriority(1);
        t2.setPriority(2);
        t3.setPriority(3);
        t4.setPriority(4);
        t5.setPriority(5);
        t6.setPriority(Thread.MAX_PRIORITY);

        //开启线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();

    }
    static class ThreadPriority implements Runnable{

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

守护线程

在这里插入图片描述

package pers.lwx.Thread;

/**
 * @program: study
 * @description: 守护线程
 * @author: codelwx
 * @create: 2021-01-12 18:01
 **/
public class DaemonDemo {
    public static void main(String[] args) {
        You you = new You();
        Gold gold = new Gold();
        Thread thread = new Thread(gold);
        thread.setDaemon(true);//默认是false表示用户线程，正餐的线程都是用户线程。。。
        thread.start();//上地守护线程启动
        new Thread(you).start();//用户线程启动

    }
}

class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程启动" + i);
        }
        System.out.println("======over=======");
    }
}

class Gold implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("上帝保佑你");
        }
    }
}

线程同步

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

三大不安全案例
不安全的银行取钱
package pers.lwx.syn;

/**
 * @program: study
 * @description: 不安全的银行取钱
 * @author: codelwx
 * @create: 2021-01-14 14:38
 **/
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Drawing myself = new Drawing(account, 50, "本人");
        Drawing girlFriend = new Drawing(account, 100, "女朋友");
        myself.start();
        girlFriend.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() {
        //同步代码块,默认锁的this（本身）。锁的是变化的量，需要增删改的对象
        synchronized (account){
            //判断有没有钱
            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);
            //Thread.currentThread().getName() = this.getName();
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}
运行结果：
结婚基金余额为：50
本人手里的钱50
女朋友钱不够，取不了
不安全的买票
package pers.lwx.syn;

/**
 * @program: study
 * @description: 不安全的买票
 * @author: codelwx
 * @create: 2021-01-14 14:21
 **/
public class UnsafeBuyTicket implements Runnable {
    private int ticketNum= 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(ticketNum <= 0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
    }

    public static void main(String[] args) {
        UnsafeBuyTicket ubt = new UnsafeBuyTicket();
        new Thread(ubt,"张三").start();
        new Thread(ubt,"李四").start();
        new Thread(ubt,"王五").start();
    }
}
运行结果：
张三拿到10
王五拿到9
王五拿到8
王五拿到7
李四拿到6
李四拿到5
王五拿到4
王五拿到3
张三拿到2
王五拿到1
不安全的线程
package pers.lwx.syn;

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

/**
 * @program: study
 * @description: 不安全的线程
 * @author: codelwx
 * @create: 2021-01-14 15:30
 **/
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(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(list.size());
    }
}
运行结果：
10000

死锁

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

package pers.lwx.syn;

import java.awt.*;

/**
 * @program: study
 * @description: 死锁测试案例
 * 死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 * @author: codelwx
 * @create: 2021-01-15 13:50
 **/
public class DeadLockDemo {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(1, "白雪公主");
        MakeUp g2 = new MakeUp(0, "灰姑娘");
        g1.start();
        g2.start();
    }
}

//口红
class LipsStick {
}

//镜子
class Mirror {
}

class MakeUp extends Thread {
    //需要的资源只要一份，用static保证只有一份
    static LipsStick lipsStick = new LipsStick();
    static Mirror mirror = new Mirror();
    int choice;//选择
    String girlName;//使用化妆品的人

    MakeUp(int Choice, String girlName) {
        this.choice = Choice;
        this.girlName = girlName;
    }

    //化妆
    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    //化妆，互相持有对方的锁，就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipsStick) {
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(2000);
            }
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
            }
        } else {
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000);
            }
            synchronized (lipsStick) {
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

Lock锁

在这里插入图片描述
ReentrantLock：可重入锁
在这里插入图片描述
在这里插入图片描述

package pers.lwx.syn;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @program: study
 * @description: 锁的测试案例
 * @author: codelwx
 * @create: 2021-01-15 14:30
 **/
public class LockDemo{
    public static void main(String[] args) {
        LockDemo01 lockDemo = new LockDemo01();
        new Thread(lockDemo).start();
        new Thread(lockDemo).start();
        new Thread(lockDemo).start();
    }
}
class LockDemo01 implements Runnable{
    int ticketNums = 10;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try {
                lock.lock();
                if(ticketNums > 0 ){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"："+ticketNums--);
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

线程协作（问题：生产者消费模式）

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

管道法
package pers.lwx.syn.生成者消费者问题;

/**
 * @program: study
 * @description: 测试：生成者消费者模型-》利用缓冲区解决：管程法
 * 生产者 消费者 产品 缓冲区
 * @author: codelwx
 * @create: 2021-01-15 14:48
 **/
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Producer extends Thread {
   SynContainer container;
   public Producer(SynContainer container){
       this.container = container;
   }
   //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(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(chickens.length == count){
            //通知消费者消费,等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没有满，生产产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费
        this.notify();
    }
    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 pers.lwx.syn.生成者消费者问题;

/**
 * @program: study
 * @description: 信号灯法
 * @author: codelwx
 * @create: 2021-01-15 20:24
 **/
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.flag = !this.flag;
        this.voice = voice;
    }
    //观看
    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 pers.lwx.syn.线程池;

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

/**
 * @program: study
 * @description: 线程池
 * @author: codelwx
 * @create: 2021-01-15 20:50
 **/
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.submit(new MyPool());
        service.submit(new MyPool());
        service.submit(new MyPool());
        service.submit(new MyPool());
        //2.关闭连接
        service.shutdown();
    }
}

class MyPool implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
python3多线程实战（python3经典编程案例）
数据知道的博客
08-25 8万+
总结： python多线程适用在I/O密集型的任务中。对于I/O密集型任务来说，较少的时间用在cpu计算上，较多的时间用在I/O上，如文件读写，web请求，数据库请求等； 对于计算密集型任务，应该使用多进程。 一. 多线程任务对比 线程也是轻量级进程，是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程的实际运作单位 一个线程可以创建和撤销另一个线程，同一进程的多个线程之间可以并发执行。 线程有就绪，阻塞，运行3中基本状态。 计算密集型任务-多进程 from multiprocessing i
python sqlite3 多线程_在python中多线程访问sqlite3数据库
weixin_32753181的博客
03-01 2983
Python标准库中有sqlite3模块，可见对此数据库的认可。不过，此模块在使用时也有限制，同一个数据库连接，不能在不同线程中共享。import threadingimport sqlite3sqlite_mutex = threading.Lock()db = sqlite3.connect('tdb2')def initdb():try:db.executescript("""create ...
python sqlite3 线程池封装
cliffordl的专栏
01-24 1753
然后，在执行数据库操作之前，我们使用 lock.acquire() 获取锁，确保只有一个线程可以执行数据库查询。因为在python操作某个数据库的数据的线程必须和创建数据库的线程是同一个线程，不然就会出现异常。check_same_thread=False的作用: python sqlite3的线程模式默认串行, 如果需要再多线程中用一个句柄，需要加此参数，否则将出现上述错误。这种方式可以确保在并发访问sqlite3数据库时，每次只有一个线程可以执行数据库操作，避免了数据竞争和不一致性的问题。
Java通俗易懂30天 第19天:多线程(下)
程序员小刘
09-16 1296
文章目录 文章目录文章目录第8章 多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例模式之懒汉式死锁的问题Lock锁方式解决线程安全问题线程的通信sleep()和wait()的异同经典例题：生产者/消费者问题JDK5.0新增线程创建方式创建多线程的方式三：实现Callable接口使用线程池的好处创建多线程的方式四：使用线程池 ..
多线程详解
最新发布
weixin_44250247的博客
05-08 964
线程是cpu任务调度的最小执行单位，每个线程拥有自己独立的程序计数器、虚拟机栈、本地方法栈。：创建、就绪、运行、阻塞、死亡。
Java--读写锁的实现原理
yupi1057的博客
06-23 9508
最近做的一个小项目中有这样的需求：整个项目有一份 config.json 保存着项目的一些配置，是存储在本地文件的一个资源，并且应用中存在读写（读&gt;&gt;写）更新问题。既然读写并发操作，那么就涉及到操作互斥，这里自然想到了读写锁，也顺便对自己读写锁方面的知识做个梳理。为什么需要读写锁？与传统锁不同的是读写锁的规则是可以共享读，但只能一个写，总结起来为： 读读不互斥，读写互斥，写写互斥 ，而...
读写锁的原理与实现
潜心钻研技术
04-19 1549
对于生产者和消费者模型的概念图👇那么我们读写锁源自读者写着模型，和生产者和消费者模型十分类似👇两个的模型实际上是一模一样的，我们还是通过“三二一”来深入了解一下读者写者模型三种关系读者-读者：没有关系，共享公共资源读者-写者：互斥、同步，因为读的时候发生了写或写的时候来读，读取到的信息都是错误的！！写者-写者：互斥，临界资源中当有一个写者时其他所有人（不论你是读者还是写者）都进不来两者角色：写者和读者一个场所：临界区生产者和写者两个是一模样的，都是向临界区输入数据的读者和消费者。
Java并发包中的读写锁及其实现分析
极北三少
11-02 635
1. 前言 在Java并发包中常用的锁（如：ReentrantLock），基本上都是排他锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。 除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁
实战指南：理解 ThreadLocal 原理并用于Java 多线程上下文管理
热门推荐
张彦峰的博客
12-01 10万+
探讨如何基于实现一个高效的上下文管理组件，以解决多线程环境下的数据共享和上下文管理这些问题。通过具体的代码示例和实战展示如何为多线程编程提供一种简洁而高效的上下文管理方案。
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Java 读写锁实现原理浅析
08-27
主要介绍了Java 读写锁实现原理浅析,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
Java读写锁实现原理
m0_37235955的博客
04-15 245
最近做的一个小项目中有这样的需求：整个项目有一份config.json保存着项目的一些配置，是存储在本地文件的一个资源，并且应用中存在读写（读>>写）更新问题。既然读写并发操作，那么就涉及到操作互斥，这里自然想到了读写锁，本文对读写锁方面的知识做个梳理。 为什么需要读写锁？ 与传统锁不同的是读写锁的规则是可以共享读，但只能一个写，总结起来为：读读不互斥，读写互斥，写写互斥，而一般的...
【并发编程】读写锁的实现原理（RWMutex）
了 凡
10-31 2150
博主介绍： – 我是了 凡，喜欢每日在简书上投稿日更的读书感悟笔名：了凡。专注于 Go Web 后端，了解过一些Python、Java、算法、前端等领域。微信公众号【了凡银河系】期待你的关注。未来大家一起加油啊~
【C++多线程】Lambda表达式
qq18218628646的博客
09-20 542
Lambda 表达式可以说是c++11引用的最重要的特性之一，虽然跟多线程关系不大，但是它在多线程的场景下使用很频繁，所以在多线程这个主题下介绍它更合适。Lambda 来源于函数式编程的概念，也是现代编程语言的一个特点。C++11 这次终于把 Lambda 加进来了，令人非常兴奋，因为Lambda表达式能够大大简化代码复杂度(语法糖：利于理解具体的功能)，避免实现调用对象。声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写一个命名函数或者函数对象。以更直接的方式去写程序，好的可读性和可维护性。
python 多线程
weixin_34194359的博客
06-02 120
使用threading模块,写一个的关于python多线程的demo。 参考： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386832360548a6491f20c62d427287739fcfa5d5be1f000 http://www.runoob.com/pyth...
java 锁实现_Java–读写锁的实现原理
weixin_39860757的博客
02-12 247
最近做的一个小项目中有这样的需求：整个项目有一份config.json保存着项目的一些配置，是存储在本地文件的一个资源，并且应用中存在读写(读>>写)更新问题。既然读写并发操作，那么就涉及到操作互斥，这里自然想到了读写锁，也顺便对自己读写锁方面的知识做个梳理。为什么需要读写锁？与传统锁不同的是读写锁的规则是可以共享读，但只能一个写，总结起来为：读读不互斥，读写互斥，写写互斥，而一般的独...
关于 Java(TM) Platform SE binary 已停止工作 的解决方法
weixin_30621711的博客
07-18 2972
系统为win7 64位 之前自动更新默认为打开 在系统更新后今天发现eclipse打开一段时间之后会自动关闭 处理方案: 　　增加eclipse.ini中的内存 -- 无效 　　更新Java版本 -- 无效 　　下载最新版本eclipse -- 无效 后来使用VS2012调试发现: 找到C:\WINdows\system32\mshtml.dll 发现修改日期为"今天" ...
Java多线程进度条实现技巧
### 知识点：Java多线程进度条的实现与应用 在现代软件开发中，多线程技术是提升应用程序性能和响应能力的关键技术之一。而进度条作为一种界面元素，可以向用户直观展示长时间运行任务的完成情况，提高用户体验。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值