Java多线程

最新推荐文章于 2024-06-15 23:36:03 发布
最新推荐文章于 2024-06-15 23:36:03 发布
阅读量957 收藏 14
点赞数 24
分类专栏： Java后端学习 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43606119/article/details/135031406
版权

以下内容是狂神Java课堂笔记

线程简介

在这里插入图片描述
一个进程中可以有多个线程

在这里插入图片描述

在这里插入图片描述

线程实现

线程创建

main线程
gc线程

三种创建方式

在这里插入图片描述

Thread类就实现了Runnable接口，所以Runnable接口最重要

Callable接口在工作后使用得比较多

Thread类

在这里插入图片描述
第一种创建方式：
交替执行

在这里插入图片描述

在这里插入图片描述

如果不是用start方法，直接run()，则会先执行run()方法体再执行主线程。
注意：线程开启不一定执行，由cpu进行调度。

**多线程下载图片的样例（略过）
安装commons-io的那个包：https://blog.csdn.net/rngweskt/article/details/84181530
狂神对应讲解的视频：https://www.bilibili.com/video/BV1V4411p7EF/?p=4&spm_id_from=pageDriver&vd_source=778e40652a97cf1a0f96297054b101d7

Runnable接口

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
之所以要在代理Thread的括号中加入runnable类，是因为：
在这里插入图片描述

对比：

在这里插入图片描述

**多线程下载图片样例改用runnable接口：
https://www.bilibili.com/video/BV1V4411p7EF/?p=5&spm_id_from=pageDriver&vd_source=778e40652a97cf1a0f96297054b101d7

小结：
在这里插入图片描述
多线程并发问题

package thread;

// 多个线程同时操作同一个对象
// 买火车票为例
// 发现问题：多个线程操作同一资源的情况下，线程不安全，数据紊乱
public class TestThread3 implements Runnable{

    // ticketNum
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            // 模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " --> 拿到了第" + ticketNums-- + "张票");
        }
    }

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

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

在这里插入图片描述

Callable

*Callable：通过创建执行服务来实现多线程

在这里插入图片描述

静态代理

package thread;


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

// 好处
// 1. 代理对象可以做真实对象做不了的事情
// 2. 真实对象专注于自己的事情
public class StaticProxy {
    public static void main(String[] args) {
//        You you = new You();
//        you.inductMarry();

        Company wedding = new Company(new You());
        wedding.inductMarry();

    }
}

interface Marry {
    void inductMarry();
}

// 真实角色
class You implements Marry {
    @Override
    public void inductMarry() {
        System.out.println("I will be married!");
    }
}

// 代理
class Company implements Marry {
    // 代理-》真实目标角色
    public Marry target;
    public Company(Marry target) {
        this.target = target;
    }
    @Override
    public void inductMarry() {
        System.out.println("decorating...");
        this.target.inductMarry(); // 真实对象
        System.out.println("end...");
    }
}

其中

Company wedding = new Company(new You());
wedding.inductMarry();

可以写成

new Company(new You()).inductMarry();

这就类似于（Runnable接口实现，用到了Lamda表达式）

new Thread(() -> System.out.println("I will be married!")).start();

Lamda表达式

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

函数式接口：

interface ILike {
    void lambda();
}

传统的一个接口声明和调用：

package lambda;
// 推导lambda表达式
public class TestLambda1 {
    public static void main(String[] args) {
        ILike like = new Like(); // 这里不用Like like = new Like();是为了不暴露Like类的实现
        like.lambda();
    }

}

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

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

使用静态内部类进行简化：

package lambda;
// 推导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 like = new Like();是为了不暴露Like类的实现
        like.lambda();

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

}

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

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

转换成局部内部类：

package lambda;
// 推导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 like = new Like();是为了不暴露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();
    }
}

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

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

再转换成匿名内部类：

package lambda;
// 推导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 like = new Like();是为了不暴露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();
    }
}

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

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

进一步简化，即lambda：

package lambda;
// 推导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 like = new Like();是为了不暴露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 lambda.");
    }
}

如果有参数：

interface ILike {
    void lambda(int a, int b);
}

那么对应的lambda表达式变为：

ILike like = (int a, int b) -> {
	System.out.println("I like lambda.");
}；

可以去掉类型进行简化：（要去掉都去掉）

ILike like = null;
like = (a, b) -> {
	System.out.println("I like lambda.");
}；

可以去掉括号进一步简化：（仅有一个参数）

ILike like = null;
like = a -> {
	System.out.println("I like lambda.");
}；

可以去掉花括号进一步简化：（仅有一行语句）

ILike like = null;
like = (a, b) -> System.out.println("I like lambda.");

在这里插入图片描述

线程状态

在这里插入图片描述

在这里插入图片描述

线程方法

在这里插入图片描述

线程停止

在这里插入图片描述

表示这个方法已经过时了不建议使用

在这里插入图片描述

模拟线程停止：

package thread;

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

public class TestStop implements Runnable{
    // 1. set flag
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run..." + i++);
        }
    }

    // 2. set a public method to change flag
    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) {
                testStop.stop();
                System.out.println("Thread stop!");
            }
        }
    }
}

执行到900轮，线程flag设置为false，但是有可能存在之前线程还没执行结束的情况

在这里插入图片描述

线程休眠

在这里插入图片描述

模拟网络延时：放大问题的发生性

模拟倒计时：

在这里插入图片描述

打印系统时间：

在这里插入图片描述

每个对象都有一个锁，sleep操作不会释放锁。

线程礼让 yield

在这里插入图片描述

示例：礼让成功（不一定成功）

在这里插入图片描述

线程合并 join

在这里插入图片描述

示例：

在这里插入图片描述

线程状态观测

在这里插入图片描述

Thread.State state = thread.getState();

线程死亡或结束后不能再被启动了

线程优先级

在这里插入图片描述

示例：

package thread;

public class TestPriority {
    public static void main(String[] args) {
        // main
        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(Thread.MAX_PRIORITY); // 10
        t2.start();

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

        t4.setPriority(8);
        t4.start();
    }
}

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

在这里插入图片描述

守护线程 daemon

在这里插入图片描述

示例：

package thread;

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        User user = new User();

        // set daemon
        Thread thread = new Thread(god);
        thread.setDaemon(true);
        thread.start();

        new Thread(user).start();
    }
}

// daemon
class God implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("God bless!");
        }
    }
}

// user thread
class User implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Yolo!");
        }
        System.out.println("---END---");
    }
}

在这里插入图片描述

即使守护线程没有推出循环，但是用户线程结束，程序就结束了。

线程同步（重点）

多个线程操作同一个资源

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

在这里插入图片描述

使用队列和锁解决线程同步的问题。

在这里插入图片描述

同步方法

在这里插入图片描述

弊端：

在这里插入图片描述

示例1：只有一个对象

在这里插入图片描述

示例2：不只一个对象

在这里插入图片描述

同步块：Obj是需要修改的资源

在这里插入图片描述

示例3：

// 原来不安全的时候，list始终无法到达10000
在这里插入图片描述

// 锁上list，线程安全了
在这里插入图片描述

JUC

// 安全的类 CopyOnWriteArrayList
在这里插入图片描述

死锁

多个线程抱着对方需要的资源，形成僵持

在这里插入图片描述

在这里插入图片描述

Lock锁

在这里插入图片描述

在这里插入图片描述

示例：

// 不安全的情况

package syn;

public class TestLock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();

        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();

    }
}

// buy tickets
class Tickets implements Runnable {
    private int ticketNum = 10;
    @Override
    public void run() {
        while (ticketNum > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(ticketNum--);
        }
    }
}

加上锁后：

package syn;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();

        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();

    }
}

// buy tickets
class Tickets implements Runnable {
    private int ticketNum = 10;

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

注意这里不是：

package syn;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();

        new Thread(tickets).start();
        new Thread(tickets).start();
        new Thread(tickets).start();

    }
}

// buy tickets
class Tickets implements Runnable {
    private int ticketNum = 10;

    // 定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (ticketNum > 0) {
            try {
                lock.lock(); // 上锁
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(ticketNum--);
            } finally {
                lock.unlock(); // 解锁
            }
        }
    }
}

当多个线程同时访问共享资源（在这里是Tickets对象）时，使用锁是一种常见的方式来确保线程安全。在你的例子中，使用了ReentrantLock来实现线程同步。

在第一个代码片段中，每个线程的执行顺序如下：

  1. 线程1进入run方法，执行lock.lock()，获取锁。
  2. 线程1检查ticketNum大于0，然后打印ticketNum--，然后释放锁lock.unlock()。
  3. 线程2进入run方法，执行lock.lock()，获取锁。
  4. 线程2检查ticketNum大于0，然后打印ticketNum--，然后释放锁lock.unlock()。
  5. 线程3进入run方法，执行lock.lock()，获取锁。
  6. 线程3检查ticketNum大于0，然后打印ticketNum--，然后释放锁lock.unlock()。

因为每个线程在获取锁后都会连续执行直到释放锁，所以输出是按顺序递减的。

在第二个代码片段中，每个线程的执行顺序如下：

  1. 线程1进入run方法，执行lock.lock()，获取锁。
  2. 线程1打印ticketNum--，然后释放锁lock.unlock()，然后执行while条件检查。
  3. 线程2进入run方法，执行lock.lock()，获取锁。
  4. 线程2打印ticketNum--，然后释放锁lock.unlock()，然后执行while条件检查。
  5. 线程3进入run方法，执行lock.lock()，获取锁。
  6. 线程3打印ticketNum--，然后释放锁lock.unlock()，然后执行while条件检查。

因为while条件检查发生在锁内部，每个线程在释放锁后会重新检查while条件，所以输出是同时递减的。

在第二个代码片段中，while条件检查发生在锁内部，这可能导致检查时机的混乱。因为每个线程在释放锁之后会重新检查while条件，所以在释放锁和再次检查条件之间，其他线程可能已经修改了共享的ticketNum值。

在这里插入图片描述

线程通信问题

线程协作

生产者消费者模式

在这里插入图片描述

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

  1. 管程法
    在这里插入图片描述

示例：

package thread;

public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Consumer(container).start();
    }
}

// producer
class Producer extends Thread {
    SynContainer synContainer;

    public Producer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

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

// consumer
class Consumer extends Thread {
    SynContainer synContainer;

    public Consumer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + synContainer.pop().id + "只鸡");
        }
    }
}

// chicken
class Chicken {
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

// synContainer
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) {
                throw new RuntimeException(e);
            }
        }

        // 如果没满
        chickens[count++] = chicken;

        // 通知消费者消费
        this.notify();
    }

    // 消费者消费产品
    public synchronized Chicken pop() {
        // 判断是否能消费
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        
        // 可以消费
        count--;
        Chicken chicken = chickens[count];
        
        // 通知生产者已消费
        this.notify();
        return chicken;
    }
}
  1. 信号灯法
    在这里插入图片描述
package thread;

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) tv.play("show!!!");
            else tv.play("ad!!!");
        }
    }
}

// 消费者 -- 观众
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 {
    // 演员表演，观众等待
    // 观众观看，演员等待
    String voice; // 节目
    boolean flag = true;

    // 表演
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        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) {
                throw new RuntimeException(e);
            }
        }

        System.out.println("观看了" + voice);

        // 通知表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

线程池

在这里插入图片描述

package thread;

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

        // 2. 关闭服务
        service.shutdown();
    }
}

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

在这里插入图片描述
很类似collable

cccc楚染rrrr
关注
  • 24
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4169
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
java多线程使用教程
鹏鹏2077
04-25 5280
本教程介绍了Java多线程的基本知识和使用方法，包括创建线程、实现Runnable接口、继承Thread类、线程同步、线程间通信和线程池等。多线程技术可以提高程序的并发处理能力和响应速度，但同时也带来了线程安全和同步等问题，需要合理使用同步机制来保证线程安全。使用Java提供的Lock接口可以实现更加灵活和精细的线程同步。线程间通信可以使用wait()、notify()和notifyAll()方法来实现。线程池机制可以重用线程，提高了线程的利用率和效率。掌握了这些知识，可以使用Java实现高效、安全、可靠的
JAVA多线程是什么
qq_45022104的博客
08-31 4043
一、 什么是多线程： 我们现在所使用操作系统都是多任务操作系统(早期使用的DOS操作系统为单任务操作系统)，多任务操作指在同一时刻可以同时做多件事(可以同时执行多个程序)。 多进程:每个程序都是一个进程，在操作系统中可以同时执行多个程序,多进程的目的是为了有效的使用CPU资源，每开一个进程系统要为该进程分配相关的系统资源(内存资源) 多线程:线程是进程内部比进程更小的执行单元(执行流|程序片段),每个线程完成一个任务,每个进程内部包含了多个线程每个线程做自己的事情，在进程中的所有线程共享该进程的资源； 主
Java 多线程：彻底搞懂线程池
热门推荐
孙强 Jimmy 的博客
07-09 18万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7748
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
JAVA多线程实战
超级氯化钾的博客
07-21 2358
是计算机中的程序关于某数据集合的一次运行活动，，一个线程就是进程中一个单一顺序的控制流，进程是线程的容器，一个进程至少有一个线程，一个进程可以有多个线程OS中是以进程为单位分配资源，如虚拟存储控件、文件描述符。每个线程都有自己的线程栈JVM启动时会自动创建一个主线程，该主线程负责执行main方法。主线程就是运行main方法的线程。.........
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程进度条
02-10
java多线程进度条
java多线程
05-02
Java多线程
力扣416 分割等和子集 Java版本
m0_47066863的博客
06-14 434
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 438
力扣136. 只出现一次的数字
[力扣题解] 236. 二叉树的最近公共祖先
东皇太一在此的博客
06-10 438
用深度搜索的思想（好吧，前序、中序、后序都是深搜思想），保存寻找路径，看看找到2个节点的路径的重合部分，就可以找到最近公共祖先；
算法day25
2202_76101487的博客
06-11 381
正值少年的日常打卡

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值