线程

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量85 收藏
点赞数
分类专栏： java学习 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42045164/article/details/115007149
版权

多线程

线程、进程、多线程

说起进程，就不得不说下程序。程序是指令和数据的有序结合，其本身没有任何运行的含义，是一个静态的概念。而进程则是执行程序的一次执行过程，她是一个动态的概念。是系统资源分配的单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少包含一个线程，不然没有存在的意义。线程是CPU调度和执行的单位
注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。
普通方法调用和多线程：
在这里插入图片描述

  1. 线程就是独立运行的路径。
  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程。
  3. main()称之为主线程，为系统的入口，用于执行整个程序。
  4. 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
  5. 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制。
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

继承Thread类

三种创建方式：1.继承Thread类（重点）

//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
public class TestThread extends Thread {
    @Override
    public void run() {
        super.run();
        //run方法线程体
        for (int i = 0; i < 50; i++) {
            System.out.println("线程---"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread testThread=new TestThread();
        //调用start()方法开启线程
        testThread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }
}
//总结：注意，线程开启不一定立即执行，由cpu调度执行

			2.实现Runnable接口（重点）

//创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法

//定义MyRunnable类实现Runnable接口
//实现run()方法，编写线程体
//创建线程对象，调用start()方法启动线程
public class TestThread1 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 50; i++) {
            System.out.println("线程---"+i);
        }

    }

    public static void main(String[] args) {
        //创建Runnable接口实现类对象
        TestThread1 testThread1=new TestThread1();
        new Thread(testThread1).start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程---"+i);
        }

    }
}

			3.实现Callable接口（了解）
			（1）实现Callable接口，需要返回值类型
			（2）重写call'方法，需要抛出异常
			（3）创建目标对象，
			（4）创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(1)
			（5）提交执行:Future<Boolean> result=ser.submit(1)
			（6）获取结果:boolean r1=result.get()
			（7）关闭服务:ser.shutdownNow()
			**小结**：
					1.继承Thread类
					（1）子类继承Thread类具备多线程能力
					（2）启动线程：子类对象.start()
					（3）不建议使用，避免OPP单继承局限性
					2.实现Runnable接口
					（1）实现接口Runnable具有多线程能力
					（2）启动线程：传入对象+Thread对象.start()
					（3）推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

并发问题

买票问题

//多个线程同时操作同一个对象
//买火车票的例子
public class TestThread2 implements Runnable{
    //票数
    private int ticketNums=10;
    @Override
    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) {
        TestThread2 testThread2=new TestThread2();

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

结果出现数据错误：
在这里插入图片描述

龟兔赛跑案例

1.首先来个赛道距离，然后要离终点越来越近
2.判断比赛是否结束
3.打印出胜利者
4.龟兔赛跑开始
5.故事中是乌龟赢得，兔子需要睡觉，所以模拟兔子睡觉
6.乌龟赢得比赛

//模拟龟兔赛跑
public class 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=gamaOver(i);
            //如果比赛结束了，就停止程序
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gamaOver(int steps){
        //判断是否有胜利者
        if(winner!=null){//存在胜利者
            return true;
        }else {
            if(steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("Winner is"+ winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Race race=new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

静态代理

结婚案例

你：真实角色
婚庆公司：代理你。帮你处理结婚的事
结婚：都实现结婚接口即可

//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处
    //代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情
public class StacticProxy {
    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("结婚前.........");
    }
}

Lamda表达式

  1. 避免匿名内部类定义过多
  2. 其实质属于函数式编程概念
    (params)->expression[表达式]
    (params)->statement[语句]
    (params)->{statements}

为什么要使用lambda表达式：
1.避免匿名内部类定义过多
2.可以让你的代码看起来很简洁
3.去掉一堆没有意义的代码，只留下核心的逻辑

函数式接口

Functional Interface(函数式接口)是学习lambda表达式的关键所在。
函数式接口的定义：任何接口，如果只包含唯一一个抽象方法，那么它就是函数式接口

 public interface Runnable(){
   			public abstract void run();
   }

对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

package lsc.threadDemo;

public class TestLambda {
    //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 lambda");
    }
}

线程状态

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

线程方法

在这里插入图片描述

线程停止

不推荐使用JDK提供的stop()、destroy()方法。推荐让线程自己停止下来，建议使用一个标志位终止变量，当flag=false，则终止线程运行。


//测试stop
//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++);
        }
    }
    //设置一个公开的方法停止线程，转换标志位
    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==300){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("该线程停止了");
            }
            
        }
    }
}

线程休眠

  1. sleep(时间)指定当前线程阻塞的毫秒数
  2. sleep存在异常InterruptedException
  3. sleep时间达到后线程进入就绪状态
  4. sleep可以模拟网络延时，倒计时等
  5. 每一个对象都有一个锁。sleep不会释放锁

线程礼让

1.礼让线程，让当前正在执行的线程暂停，但不阻塞
2.将线程从运行状态转换为就绪状态
3.让CPU重新调度，礼让不一定成功

join

join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
可以想象成插队

线程状态观测

线程状态。线程可以处于一下状态之一：
1.NEW
尚未启动的线程处于此状态
2.RUNNABLE
在Java虚拟机中执行的线程处于此状态
3.BLOCKED
被阻塞等待监视器锁定的线程处于此状态
4.WATING
正在等待另一个线程执行特定动作的线程处于此状态
5.TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
6.TERMINATED
已退出的线程处于此状态

一个线程可以在给定时间点处于一个状态。这些状态是不反应任何操作系统线程状态的的虚拟机的状态

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有进程，线程调度器按照优先级决定应该调度哪个线程来执行。
线程的优先级用数字来表示，范围从1~10。

  1. Thread_MIN_PRIORITY=1；
  2. Thread_MAX_PRIORITY=10;
  3. Thread_MAX_PRIORITY=5;
    使用以下方式改变或获取优先级
    getPriority() setPriority(int xxx)
    注意：优先级低只意味着获得调度的概率低，并不是优先级低就不会被调用。这都是看CPU的调度。

守护线程

  1. 线程分为用户线程和守护线程
  2. 虚拟机必须确保用户线程执行完毕
  3. 虚拟机不用等待守护线程执行完毕
  4. 如：后台记录操作日志，监控内存，垃圾回收等待…

线程同步机制

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

现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如：食堂排队打饭，每个人都想吃饭，最天然的解决办法就是，排队，一个个来
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这个时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要访问此对象的线程进入这个对象的等待池，等待前面线程使用完毕，下一个线程再使用
线程同步形成条件：队列+锁
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：

  1. 一个线程持有锁会导致其他所有需要此锁的进程挂起
  2. 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  3. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

同步方法

  1. 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块
    同步方法：public synchronized void method(int args){}
  2. synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放，后面被阻塞的线程才能获得这个锁，继续执行。
    缺陷：若将 一个大的方法申明为synchronized将会影响速率
    同步方法弊端：方法里面需要修改的内容才需要锁，锁的太多，浪费资源

同步块

  1. 同步块：synchronized(Obj){}
  2. Obj称之为同步监视器
    1. Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    2. 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
  3. 同步监视器的执行过程
    1. 第一个线程访问，锁定同步监视器，执行其中代码
    2. 第二个线程访问，发现同步监视器被锁定，无法访问
    3. 第一个线程访问完毕，解锁同步监视器
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

死锁

多个线程各占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题

死锁避免方法

产生死锁的四个必要条件

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
    注意：我们只要想办法破其中的任意一个或多个条件就可以避免死锁。

Lock（锁）

  1. 从JDK5.0开始，Java提供了更强大的线程同步机制----通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  2. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
  3. ReentrantLock类实现了Lock，它拥有与 synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁，释放锁
class A{
  private final ReentrantLock lock=new ReenTrantLock();
  public void m(){
  	lock.lock();
  	try{
  			//保证线程安全的代码
  		}finally{
  			lock.unlock();
  			//如果代码同步有异常，要将unlock()写入finally语句块
  			}
  } 
}

synchronized与Lock对比

  1. Lock是显示锁(手动开启和关闭锁，别忘记关闭锁)synchronized是隐式锁，出了作用于自动释放
  2. Lock只有代码块锁，synchronized有代码锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
  4. 优先使用顺序：
    Lock>同步代码块（以及进入方法体，分配了相应资源）>同步方法（在方法体外）

生产者消费者问题

线程通信

  1. 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
  2. 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
  3. 如果仓库中放有产品，则消费者可以将产品取走，否则停止消费并等待，直到仓库中再次放入产品为止

分析

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

  1. 对于生产者，没有生产产品之前，要通知消费者进行等待，而生产产品之后，又需要马上停止消费者进行消费
  2. 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品进行消费
  3. 在生产者消费者问题中，仅有synchronized是不够的
    1. synchronized可阻止并发更新同一个资源，实现了同步
    2. synchronized不能用来实现不同线程之间的消息传递（通信）

Java提供了几个方法解决线程之间的通信问题：
在这里插入图片描述

解决方法

1.管程法

并发协作模型“生产者/消费者模式”---->管程法

  1. 生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
  2. 消费者：负责处理数据的模块（可能是方法、对象、线程、进程）
  3. 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”
    生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
//并发协作模型“生产者/消费者模式”---->管程法
//生产者、消费者、产品、缓冲区
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+"只鸡");
            container.pop();
        }
    }
}
//产品
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){
        //如果容器满了，就需要等待消费者消费
        while (count==chickens.length){
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        //如果没有满，我们就需要丢入产品
        chickens[count]=chicken;
        System.out.println("生产了"+chicken.id+"只鸡");
        count++;
        //可以通知消费者消费了
        this.notifyAll();

    }
    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        while (count==0){
            //消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        System.out.println("消费了"+chicken.id+"只鸡");
        //消费完,通知生产者生产
        this.notifyAll();
        return chicken;

    }
}

2.信号灯法

并发协作模型“生产者/消费者模式”---->信号灯法

//信号灯法
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("直播-->"+i);
           }else {
               this.tv.play("抖音-->"+i);
           }
        }
    }

}
//消费者--观众
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) {
                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;
    }
}

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
好处：

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  3. 便于线程管理（…）
    1. corePoolSize:核心池的大小
    2. maximumPoolSize：最大线程数
    3. keepAliveTime：线程没有任务时最多保持多长时间后会终止
  4. JDK5.0起提供了线程池相关API：ExecutorService和Executors
  5. ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    1. void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
    2. Futuresubmit(Callabletask):执行任务，有返回值，一般用来执行Callable
    3. void shutdowm():关闭连接池
  6. Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
梦回千里琥珀晨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程生命周期
weixin_43178406的博客
09-14 3万+
本文主要介绍了线程生命周期，希望能对学习线程的同学们有所帮助。 文章目录 1. 综述 2. 线程的生命周期
C#高级--多线程详解
李宥的博客
10-03 5万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
进程和线程的区别(超详细)
热门推荐
ThinkWon的博客
10-03 40万+
进程和线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。 线程 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。 与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟...
Java多线程实战-CountDownLatch模拟压测实现
qq_35716689的博客
03-17 24万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
【多线程】线程池
王佑辉的博客
04-04 5369
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
python创建线程和结束线程
一键难忘的博客
04-22 3709
在 Python 中，线程是一种轻量级的执行单元，允许我们在程序中同时执行多个任务。线程的创建和结束是多线程编程中的核心概念之一。在本文中，我们将学习如何使用 Python 创建线程，并探讨如何优雅地结束线程。
Qt 线程
qq_45303986的博客
02-20 6736
QThread(线程)，代表一个在应用程序中可以独立控制的线程，可以和进程中的其他线程分享数据。QThread 对象管理程序中的一个控制线程。QThreads 在 run（） 中开始执行。默认情况下，run（） 通过调用 exec（） 来启动事件循环，并在线程内运行 Qt 事件循环。
1、【java线程及线程池系列】java线程及线程池概念详解
alanchanchn的专栏
06-12 4万+
缓冲队列长度的设置，按照一般的理解应该设置成maximumPoolSize的5倍，因为单个线程在不切换cpu的情况下是单个cpu运算一个线程，corePoolSize设置成和cpu一样的数量，maximumPoolSize设置成cpu的2倍，避免cpu处于空闲状态则直接加入一旦cpu空闲理解执行的线程数量，同时由于cpu的速度较快以及有请求执行的线程加入缓冲队列中减少cpu等待时间，故将缓冲队列设置大一些。线程池存在的目的在于提前创建好需要的线程，减少临时创建线程带来的资源消耗。
解析Python中获取当前线程名字的方法及多线程编程实践
一键难忘的博客
04-27 2608
在多线程编程中，了解当前线程的名字是一项重要的任务。Python 提供了内置的线程模块 `threading`，通过它我们可以轻松地获取当前线程的名字。本文将介绍如何在 Python 中获取当前线程的名字，并探讨一些相关的背景知识。
python实现多线程
qq_35778860的博客
09-11 6416
本文转载于上面的链接. 文章目录1 线程基本概念1.1 线程是什么？1.2 线程和进程关系？2 Python线程模块3 线程间同步4 线程池4.1 传统多线程问题？4.2 线程池基本原理：5 协程5.2 Send来了6. python 进行并发编程6.1 使用asyncio6.2 使用async/await7 小结 1 线程基本概念 1.1 线程是什么？ 线程是指进程内的一个执行单元...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Linux 多线程原理深剖
qq_61500888的博客
12-24 4万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
spring事务详细讲解-深入浅出
小电玩
09-08 397
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1407
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1337
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合——Stack详解
最新发布
yang_brother的博客
09-10 270
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 678
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值