JAVA多线程

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量95 收藏
点赞数
分类专栏： JAVA 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45820184/article/details/126444035
版权

1 概念

1.1 普通方法调用和多线程

在这里插入图片描述

1.2 程序、进程、线程

（1）
在这里插入图片描述
（2）
在这里插入图片描述
（3）核心概念
在这里插入图片描述

2 线程的创建

在这里插入图片描述

2.1 Thread

在这里插入图片描述
（1）

// 创建方式一：继承Thread类，重写run()方法，调用start开启线程
// 总结：注意，线程开启不一定立即执行，由CPU调度
public class Demo1_Thread extends Thread{
        public void run(){
            // run方法线程体
            for(int i=0;i<200;i++){
                System.out.println("我在看代码");
            }
        }

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


            // mian线程，主线程
            for(int i=0;i<1000;i++){
               System.out.println("我在学习多线程--"+i);
            }

        }
}

在这里插入图片描述
（2）

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

    public Demo2_Thread(String url,String name){  //构造器
        this.url=url;
        this.name=name;
    }
    //下载图片线程的执行体
    public void run(){
        WebDownloader webDownloader =new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为:"+name);
    }

    public static void main(String[] args) {
        Demo2_Thread t1 =new Demo2_Thread("https://t7.baidu.com/it/u=4198287529,2774471735&fm=193&f=GIF","1.jpg");
        Demo2_Thread t2 =new Demo2_Thread("https://t7.baidu.com/it/u=825057118,3516313570&fm=193&f=GIF","2.jpg");
        Demo2_Thread t3 =new Demo2_Thread("https://t7.baidu.com/it/u=3435942975,1552946865&fm=193&f=GIF","3.jpg");

        //启动线程
        t1.start();
        t2.start();
        t3.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.2 Runnable

在这里插入图片描述
（1）

// 创建线程方法2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实例，调用start方法。
public class Demo1_Runnable implements Runnable{
    public void run(){
        // run方法线程体
        for(int i=0;i<200;i++){
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        // 创建runnable接口的实现类对象
        Demo1_Runnable t1=new Demo1_Runnable();

        // 创建线程对象，通过线程对象来开启我们的线程
        new Thread(t1).start();

        /*
        Thread thread =new Thread(t1);
        thread.start();
        * */

        // mian线程，主线程
        for(int i=0;i<1000;i++){
            System.out.println("我在学习多线程--"+i);
        }

    }
}

在这里插入图片描述

在这里插入图片描述

（2）

//多个线程同时操作同一个对象
//买火车票的例子

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。------线程并发问题
public class Demo2_Runnable implements Runnable{

    // 票数
    private int ticketNums =10;

    public void run(){
        while(true){
            if(ticketNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

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

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

在这里插入图片描述
（3）
在这里插入图片描述

//模拟龟兔比赛
public class Demo3_Race implements Runnable{

    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i= 0;  i<= 100; i++) {

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

            //判断比赛是否结束
            boolean flag=gameOver(i);
            //如果比赛结束了，就停止程序
            if (flag){
                break;
            }

            System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if(winner!=null){ //已经有胜利者
            return true;
        }{  //这里不是if else。但这里不写else却能和else有一样的效果。这里的｛｝只是一个代码块，可以不写｛｝，方便理解。
            if(steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Demo3_Race race=new Demo3_Race();

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

2.3 Callable

在这里插入图片描述

3 静态代理

把要实现的内容放在代理类里面，然后再到main方法里面创建代理类对象，然后传参要结婚的那个人

// 使用静态代理模拟结婚，对比Thread类

/*
静态代理模式总结：
    真实对象和代理对象都要实现同一个接口；
    代理对象要代理真实角色；
好处：
    代理对象可以做很多真实对象做不了的事情；
    真实对象专注做自己的事情；
 */
public class StacticProxy {
    public static void main(String[] args) {
        /*
        You you = new You();
        you.HappyMarry();
        本来是你结婚，调用你结婚的方法。
        但婚庆公司可可以代理，把你给婚庆公司就可以
         */
        
        new Thread(()-> System.out.println("我爱你")).start();

        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{  //你  真实角色，你去结婚
    @Override
    public void HappyMarry() { //重写接口的方法
        System.out.println("Ks要结婚了，超开心！");
    }
}

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

4 Lambda表达式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（1）

/*
推导lambda表达式
 */
public class TestLambda1 {

    //3.静态内部类
    static class Like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2!");
        }
    }

    public static void main(String[] args) {
        Ilike like = new Like();
        like.lambda();

        like=new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3!");
            }
        }
        like=new Like3();
        like.lambda();

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

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

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

//2.实现类
class Like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("I like lambda1!");
    }
}

在这里插入图片描述
（2）

public class TestLambda2 {

    public static void main(String[] args) {

        //lambda，去掉匿名内部类，去掉函数名
        ILove love = (int a) -> {
            System.out.println("I love you-->" + a);
        };

        love.love(520);
    }
}
interface ILove {
        void love(int a);
}

5 线程状态

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

5.1 线程停止

在这里插入图片描述

/*
测试stop
1.建议线程正常停止--->利用次数，不建议死循环。
2.建议使用标志位--->设置一个标志位
3.不要使用stop或destory等过时或者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.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

在这里插入图片描述

5.2 线程休眠- sleep

在这里插入图片描述
（1）模拟网络时延

//模拟网络时延
public class TestSleep1 implements Runnable{

    // 票数
    private int ticketNums =10;

    public void run(){
        while(true){
            if(ticketNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

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

        //多个线程实现一个对象，不安全
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }
}

在这里插入图片描述
（2）模拟倒计时

//模拟倒计时
public class TestSleep2 {

    public static void main(String[] args) {
        try {
            tenDown();
        } 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;
            }
        }
    }
}

在这里插入图片描述
（3）获取当前系统时间

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

//打印当前系统时间
public class TestSleep3 {

    public static void main(String[] args) {

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

    }

}

5.3 线程礼让- yield

1

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

在这里插入图片描述

5.4 线程强制执行(插队)- join

在这里插入图片描述

//测试join方法，想象为插队
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);
        thread.start();

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

在这里插入图片描述

多核CPU在200之前会交替执行。对于这个例子有疑问
因为这个代码子线程thread是主线程触发条件前就start()了，就能看到子线程先跑完了，所以子线程输出穿插在主线程运行到判断条件前。

5.5 线程状态观测

在这里插入图片描述

//观测线程状态
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            System.out.println("/");
        });

        //观察状态
        Thread.State state =thread.getState();
        System.out.println(state); //new

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

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

    }
}

在这里插入图片描述

5.6 线程优先级

在这里插入图片描述

//线程的优先级 1——10 逐渐增高
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);

        //先设置优先级，再启动

        t1.start();

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

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

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();
    }
}

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

在这里插入图片描述

5.7 守护线程

在这里插入图片描述

//测试守护线程 （只要用户线程结束，虚拟机也会结束【无视守护线程是否结束】）
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!====-");
    }
}

在这里插入图片描述

6 线程同步(多个线程操作同一个资源)

并发：同一个对象被多个线程同时操作
线程同步：处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用。
形成条件：队列和锁
在这里插入图片描述

6.1 同步方法及同步块

（1）同步方法
在这里插入图片描述
（2）同步块
在这里插入图片描述

6.2 死锁（多个线程互相抱着对方需要的资源，然会形成僵持）

在这里插入图片描述

在这里插入图片描述

6.3 lock锁

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

7 线程协作（生产者消费者模式）

7.1 线程通信

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

7.2 解决方式

（1）管程法

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

//生产者，消费者，产品，缓冲区
public class TubeMethod {
    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;
    }

}

在这里插入图片描述

（2）信号灯法

//测试生产者消费者问题2：信号灯法，标志位解决
public class SignalLightMethod {

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

}

在这里插入图片描述

7.3 线程池

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

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

//测试线程池
public class TestPool {
    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() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}

在这里插入图片描述

CHD-Kang
关注
专栏目录
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
Java多线程——线程同步
u010759175的专栏
12-28 2964
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
编程必备：JAVA多线程详解
拾一二的博客
06-14 8563
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 6253
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java 多线程的应用场景
才哈哈的博客主页
05-01 1万+
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
Java-网络
最新发布
2301_81543552的博客
09-14 701
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 611
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 284
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1143
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值