让你10分钟完全了解什么是多线程！！

最新推荐文章于 2024-03-13 07:05:10 发布
最新推荐文章于 2024-03-13 07:05:10 发布
阅读量496 收藏 1
点赞数 2
分类专栏： xzk 文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liyq_19/article/details/111602885
版权

1、进程和线程是什么

  • 进程：是CPU的资源调度单位，一个运行的程序，软件就是一个进程，每个进程有自己独立的内存空间
  • 线程：是在进程中的，是程序执行的路径，多个线程相当于是主线程main的分支，共享同一个内存空间

注意：main其实也是一个线程，主线程！

2、线程调度

分时调度

  • 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，

Java使用的为抢占式调度。

  • CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高

3、同步与异步

  • 同步： 相当于十个大汉，排队吃一桶饭，一个一个来，安全但是效率不高
  • 异步：十个大汉，同时吃一桶饭，效率高，但是不安全，容易产生冲突

4、并发与并行

  • 并发：同一个时间段，请求数量
  • 并行：同一时间的请求数量

5、创建线程方法

  1. 创建一个类继承Thread类，重写run方法，再调用写的类.start（）方法，调用start方法执行run
  2. 创建一个类实现Runnable，相当于写一个任务，然后new出该类，在new一个Thread，把该类传进Thread中，把任务交给Thread执行，再调用Thread的start（）

=实现Runnable接口比Thread的好处是：=

  1. 实现Runnable接口方式，相当于创建一个任务，当需要多个线程执行同个任务的时候，直接把该类传进线程中就行，特别方便
  2. 类是单继承的，实现接口有利于类的多态化
  3. 线程池的管理时，是只接受Runnable类型的任务，不接收Thread类型的线程
  4. 任务与线程本身是分离的，降低程序的耦合，提高了程序的健壮性

6、线程分守护线程和用户线程

  • 用户线程：当一个线程不包含任何的存活的用户线程是进行结束
  • 守护线程：守护用户线程的，当最后一个用户线程结束的时候，所有线程自动死亡 人在塔在！！！

7、线程中断

package com.xzk.section04.chapter05;

/**
 * @version 1.0
 * @Author: lyq
 * @Date: 2020/12/23
 * @Description: TODO
 **/
public class Demo_ThreadInterrupt {
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new MyThread());
        thread.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+i);
            Thread.sleep(1000);
        }
        thread.interrupt();

    }

    static class MyThread implements Runnable {
        @Override
        public void run() {

                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+i);//打印当前线程名字
                    try {
                        Thread.sleep(1000);//等待一秒
                    } catch (InterruptedException e) {//接收到中断标志
                        //e.printStackTrace();
                        System.out.println("接收到中断标志，中断线程");
                        //...在这期间释放该释放的资源
                        return;//结束线程
                    }

                }

        }
    }

}

8、锁

话不多说，上代码：

package com.xzk.section04.chapter05;

/**
 * @version 1.0
 * @Author: lyq
 * @Date: 2020/12/23
 * @Description: TODO 练习线程锁
 **/
public class Demo_ThreadLock {
    public static void main(String[] args) throws InterruptedException {

        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
       

    }

    /**
     * TODO 假设一个简单的需求  卖票
     *
     * @param null
     * @return: 
     **/
    static class MyThread implements Runnable {
        //10张票
        private int count = 10;
        @Override
        public void run() {

            while (true) {
                if (count > 0) {
                    try {
                        Thread.sleep(1000);//休眠一秒
                        System.out.println("票卖出一张，余票：" + (--count));
                    } catch (InterruptedException e) {
                        return;
                    }
                } else {
                    break;
                }
            }
        }
    }

}

最终结果出现：

票卖出一张，余票：-1
票卖出一张，余票：-2

原因，当第一个线程抢到了CPU抛出的时间偏，线程开始休眠一秒钟，在这期间，第二个第三个线程也抢到了时间偏，所以出现以上情况

加锁法一，加上一把对象锁：=（同步代码块=

static class MyThread implements Runnable {
    //10张票
    private int count = 10;
    Object o = new Object();
    @Override
    public void run() {

        while (true) {
            synchronized (o) {

            if (count > 0) {
                try {
                    Thread.sleep(1000);//休眠一秒
                    System.out.println(Thread.currentThread().getName()
                            +"票卖出一张，余票：" + (--count));
                } catch (InterruptedException e) {
                    return;
                }
            } else {
                break;
            }
            }
        }
    }
}

结果正常，但是效率变慢，因为是变成排队同步了

加锁法二，给方法加锁：（同步方法）

static class MyThread implements Runnable {
    //10张票
    private int count = 10;
    @Override
    public void run() {
        sale();
    }

    public synchronized void  sale() {
        while (true) {
            if (count > 0) {
                try {
                    Thread.sleep(1000);//休眠一秒
                    System.out.println(Thread.currentThread().getName()
                            +"票卖出一张，余票：" + (--count));
                } catch (InterruptedException e) {
                    return;
                }
            } else {
                break;
            }
        }
    }
}

上面两种都是隐式锁

加锁方法三：*（显式锁Lock）

显式锁（synchronized）跟隐式锁（Lock）的区别：

1.显式锁需要手动控制开关

2.显式锁不可以中断，而隐式锁可以设置超时中断，或者直接Interrupt中断

  1. Sync：非公平锁

    lock：两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。

9、公平锁与非公平锁

公平锁，先申请的先得到锁，一个个排队

非公平锁，每一个都尝试去获取锁，获取到就锁，获取不到就进行等待

10、死锁

A持有B的锁，B持有A的锁。

案例（警察与罪犯）：

package com.xzk.section04.chapter05;

/**
 * @version 1.0
 * @Author: lyq
 * @Date: 2020/12/23
 * @Description: TODO
 **/
public class Demo_ThreadDieLock {
    public static void main(String[] args) {
        Police police = new Police();
        Zuifan zuifan = new Zuifan();
        new MyThread(zuifan,police).start();
        zuifan.say(police);
    }

    public static class MyThread extends Thread {
        private Zuifan zuifan;
        private Police police;

        public MyThread(Zuifan zuifan, Police police) {
            this.zuifan = zuifan;
            this.police = police;
        }

        @Override
        public void run() {
            //在此谈判
            police.say(zuifan);
        }
    }


    //警察类
    static public class Police {

        public synchronized void say(Zuifan zuifan) {
            System.out.println("放人质，再放你");//警察谈判
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            zuifan.respond();//希望得到罪犯的回应
        }

        //警察回应
        public synchronized void respond() {
            System.out.println("你放了人质，你走吧");
        }
    }

    //罪犯类
    static public class Zuifan {

        public synchronized void say(Police police) {
            System.out.println("放过我，再放人质");//罪犯谈判
            try {
                Thread.sleep(100);      //电脑太好锁不住，加大几率
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            police.respond();//希望得到警察的回应
        }

        //罪犯回应
        public synchronized void respond() {
            System.out.println("你放了我，我把人质放了");
        }
    }
}

11、多线程同信问题（生产者与消费者）

package com.xzk.section04.chapter05;

/**
 * @version 1.0
 * @Author: lyq
 * @Date: 2020/12/23
 * @Description: TODO 多线程通信问题，消费者与生产者
 * <p>生产者生产过程中，消费者睡眠；
 *    消费者消费过程中，生产者睡眠；
 * </p>
 **/
public class Demo_ThreadsCom {
    public static void main(String[] args) {
        Food food = new Food();
        new Cooker(food).start();
        new Waiter(food).start();
    }

    //厨师，生产菜品
    static public class Cooker extends Thread {
        private Food food;

        public Cooker(Food food) {
            this.food = food;
        }

        @Override
        public  void run() {
            for (int i = 0; i < 100; i++) {
                if (i % 2 == 0) {
                    food.setNameAndTaste("猪脚饭", "酸辣味");
                } else {
                    food.setNameAndTaste("酸菜鱼", "苦甜味");
                }
            }

        }
    }

    //服务员，端菜
    static public class Waiter extends Thread {
        private Food food;

        public Waiter(Food food) {
            this.food = food;
        }

        @Override
        public  void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                food.get();//连续上菜，但需要等待100ms，不然厨师刚做好菜，可能服务员就端了一百次
            }
        }
    }
    //菜品
    static public class Food {
        private String name;
        private String taste;

        public Food() {
        }

        public String getName() {
            return name;
        }

        public  void setNameAndTaste(String name,String taste) {
            this.name = name;
            //加大多线程时候数据错乱的几率
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
        }

        public String getTaste() {
            return taste;
        }

        public  void get() {
            System.out.println("端走："+name+"味道"+taste);
        }

    }


}

简单的加锁并不能完全解决问题，因为第一个设置名字的锁，可能回首掏，刚自己释放锁有持有锁。

所以需要，让生产者生产完进行休眠，唤醒消费者，消费者消费完睡眠，唤醒生产者：

package com.java.demo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo4  {

    /**
     * 多线程通信问题, 生产者与消费者问题
     * @param args
     */
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for(int i=0;i<100;i++){
                if(i%2==0){
                    f.setNameAndSaste("老干妈小米粥","香辣味");
                }else{
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
            if(flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if(!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

12、线程的六种状态

  • 线程状态。

    线程可以处于以下状态之一：

    • NEW
      尚未启动的线程处于此状态。
    • RUNNABLE
      在Java虚拟机中执行的线程处于此状态。
    • BLOCKED
      被阻塞等待监视器锁定的线程处于此状态。
    • WAITING
      无限期等待另一个线程执行特定操作的线程处于此状态。
    • TIMED_WAITING
      正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
    • TERMINATED
      已退出的线程处于此状态。

13、创建线程的第三种方法—>Callable

Runnable 与 Callable

​ Callable使用步骤：
+ Runnable 与 Callable的相同点
1. 都是接口
2. 都可以编写多线程程序
3. 都采用Thread.start()启动线程
+ Runnable 与 Callable的不同点
1.Runnable没有返回值；Callable可以返回执行结果
2.Callable接口的call()允许抛出异常；Runnable的run()不能抛出
+ Callable获取返回值
Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行， 如果不调用不会阻塞。

接口定义

//Callable接口

public interface Callable {

V call() throws Exception;

}

//Runnable接口

public interface Runnable {

public abstract void run();

}

1. 编写类实现Callable接口 , 实现call方法
   class XXX implements Callable {
   @Override
   public  call() throws Exception {
   return T;
   }
   }
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
   FutureTask future = new FutureTask<>(callable);
3. 通过Thread,启动线程
   new Thread(future).start();

14、线程池

线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

Java中的四种线程池 . ExecutorService

  1. 缓存线程池
/**
* 缓存线程池.
* (长度无限制)
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中 加入 新的任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
  1. 定长线程池
/**
* 定长线程池.
* (长度是指定的数值)
* 执行流程:
3. 单线程线程池
4. 周期性任务定长线程池
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

  1. 单线程线程池

    效果与定长线程池 创建时传入数值1 效果一致.
/**
* 单线程线程池.
* 执行流程:
* 1. 判断线程池 的那个线程 是否空闲
* 2. 空闲则使用
* 4. 不空闲,则等待 池中的单个线程空闲后 使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName());
}
});

    ​

4.周期性任务定长线程池

public static void main(String[] args) {
/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿");
}
},5,2,TimeUnit.SECONDS);
}
戛然而
关注
专栏目录
多线程中的Join
柯基的博客
09-16 2773
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
五种线程池的分类和作用
weixin_30780649的博客
07-17 1573
1、newCachedThreadPool 作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。 特征：（1）线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）（3）当线程池中，没有可用线程，会重新创建一...
Java 浅析 Thread.join()
xiaochengxuyuan1的博客
01-12 170
1. join() 的示例和作用 1.1 示例 1 // 父线程 2 public class Parent { 3 public static void main(String[] args) { 4 // 创建child对象，此时child表示的线程处于NEW状态 5 Child child = new Child(); 6 // child表示的线程转换为RUNNABLE状态 7 child.start(); 8
QThread的用法
热门推荐
HuZhenXing
08-06 8万+
概述 QThread类提供了一个与平台无关的管理线程的方法。一个QThread对象管理一个线程。QThread的执行从run()函数的执行开始，在Qt自带的QThread类中，run()函数通过调用exec()函数来启动事件循环机制，并且在线程内部处理Qt的事件。在Qt中建立线程的主要目的就是为了用线程来处理那些耗时的后台操作，从而让主界面能及时响应用户的请求操作。下面就谈谈如何利用QT
Java线程池面试题
程序员世杰
10-14 898
一、什么是线程池？ 线程池是一种多线程处理形式，处理过程中将任务提交到线程池，任务的执行交由线程池来管理。 如果每个请求都创建一个线程去处理，那么服务器的资源很快就会被耗尽，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 二、为什么要使用线程池？ 创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上...
11.Qt多线程_QT多线程_
09-29
Qt框架中的多线程技术是开发高效、响应性应用程序的关键工具。在现代计算机系统中，多线程允许程序同时执行多个任务，提升程序性能并优化用户体验。本示例旨在教授如何在Qt环境中有效地利用多线程，特别是通过`...
Android多线程：完全解析线程池ThreadPool原理&使用
02-25
1.对于多线程，大家应该很熟悉。但是，大家了解线程池吗？2.今天，我将带大家全部学习关于线程池的所有知识。线程池中有6个核心参数，具体如下上述6个参数的配置决定了线程池的功能，具体设置时机=创建线程池类对象...
JAVA-多线程 所有文件
01-09
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨...
浅析java volatitle 多线程问题
09-05
Java中的`volatile`关键字在多线程编程中扮演着至关重要的角色，它是Java内存模型（JMM）的一部分，用于处理并发环境中的数据同步问题。在理解`volatile`的关键作用前，我们先要了解Java内存模型的基本概念。在JVM中...
线程池的分类
m0_59640751的博客
08-05 224
1、缓存线程池： * 当线程执行后，由于线程池里已经有缓存的相同线程了，再创建一个新的相同的，他会调用线程池里的来运行 * (长度无限制) * 任务加入后的执行流程 * 1、判断线程池是否存在空闲线程 * 2、存在则使用 * 3、不存在，则创建线程，并放入线程池，然后使用 2、定长线程池： * （长度是指定的数值） * 任务加入后的执行流程 * 1、判断线程池里是否存在空闲线程 * 2、存在则使用 * 3、不存在空闲线程，且线程未满的情况下，则创建线程池，然后使用 * 4、不存在空闲线程，且线程已
Join java_Java中Thread.join()的使用方法
weixin_28797889的博客
02-12 124
概要本文分三个部分对Thread.join()进行分析：1. join() 的示例和作用2. join() 源码分析3. 对网上其他分析 join() 的文章提出疑问1. join() 的示例和作用1.1 示例// 父线程public class Parent {public static void main(String[] args) {// 创建child对象，此时child表示的线程处于N...
Java Thread join() 的用法
AugusLee的专栏
12-05 223
Java Thread中， join() 方法主要是让调用改方法的thread完成run方法里面的东西后， 在执行join()方法后面的代码。示例：[code="java"]class ThreadTesterA implements Runnable { private int counter; @Override public void run() { while (...
qt 等待线程结束_QT5线程关闭
weixin_33542015的博客
12-24 4383
QT5线程关闭QThread析构函数的说明:请注意，删除一个QThread对象不会停止它管理的线程的执行。 删除正在运行的QThread(即isFinished()返回false)将导致程序崩溃。 在删除QThread之前等待finished()信号。从Qt4.8起，可以释放运行刚刚结束的线程对象，通过连接finished()信号到QObject::deleteLater()。QThread类qu...
java thread join方法_JAVA THREAD.JOIN方法详解
weixin_42515392的博客
02-16 1297
一、使用方式。join是Thread类的一个方法，启动线程后直接调用，例如：Thread t = new AThread(); t.start(); t.join();二、为什么要用join()方法在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之...
Java高并发3-中断线程以及isInterrupted与interrupted区别
weixin_44630050的博客
10-31 570
一、复习上一节内容 wait()方法、中断正在运行的线程会抛出java.lang.InterruptedException、当线程调用共享对象的wait()方法时，当前线程只会释放当前共享变量的锁，不会释放该线程所持有的其他共享变量的锁。 wait(long timeout,int nanos）实现、wait(0)内部调用了wait()方法、notify()随机唤醒、notifyAll()全部唤醒、join方法、sleep方法、yield方法，以及sleep与yield方法的区别 二、线程中断inter
线程池的种类
最新发布
qq_43012298的博客
03-13 695
以下是创建自定义线程池的示例，设置了核心线程数、最大线程数、存活时间、工作队列等参数。timeUnit,workQueue,在这个自定义线程池中，我们指定了核心线程数和最大线程数，还有一个有界工作队列。如果线程池忙碌且队列满了，那么拒绝策略将会使提交任务的线程自己执行该任务。总的来说，线程池的选择和配置都取决于具体应用的需求，要注意合理地利用系统资源，避免过多的线程导致的上下文切换开销，以及线程池和队列大小设置不当造成的资源耗尽风险。
线程池类型
weixin_51315931的博客
02-05 3827
对于线程池的一个初步了解
线程池的种类有哪些？
码放南山
02-29 7076
目录 一、可缓存线程池（NewCachedThreadPool） 二、 指定工作线程的线程池（NewFixedThreadPool） 三、定时的线程池newScheduledThreadPool 四、单线程线程池（NewSingleThreadExecutor） 一、可缓存线程池（NewCachedThreadPool） 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时...
QThread的正确使用方法
C_arm的专栏
03-26 1724
点击打开原文链接 qt自带的文档和例子中使用QThread都是继承QThread，然后重载run， 今天想在继承自QThread类中自定义一个槽，觉得对QThread的信号-槽的机制在多线程的情况下有些不清楚的地方，猜想QThread的槽并不是执行在QThread实例创建的子线程中，但我需要让槽执行在子线程中，查了一下资料，发现了QThread更好的使用方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值