多线程

最新推荐文章于 2024-03-27 14:44:09 发布
最新推荐文章于 2024-03-27 14:44:09 发布
阅读量115 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45685359/article/details/103326737
版权

1、进程的概述及多进程的意义

多任务：一个人边吃饭边玩手机。本质是大脑同一时间只做了一件事。
多线程：一条道路，车比较多，堵塞、效率低。增加车道，提高效率，这就是多线程。

1.1进程和线程

线程是依赖于进程存在的。
比如一个视频进程，它里面就有多个线程：图片、声音、字母等等。

1.2进程（Process）的概述

在操作系统中运行的程序就是进程。比如qq等。
通过任务管理器可以看到进程的存在。
任务管理器中的进程
通过观察，发现只有在运行中的程序才会出现进程。

  • 进程：就是正在运行的程序。
  • 进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存和系统资源。

1.3多进程的意义

  • 单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
  • 举例：一边玩游戏（游戏进程），一边听音乐（音乐进程）。
  • 现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务，提高CPU的使用率。
  • 问题
    对于单核计算机来说，游戏进程和音乐进程是同时运行的吗？
  • 不是。因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，且切换速度快。所以让我们感觉是在同时执行。
  • 多进程的作用不是提高执行速度，而是提高CPU的使用率。

2、线程的概述和多线程的意义

2.1线程的概述

在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。

  • 线程：是程序的执行单元，执行路径。是程序使用CPU的基本单位。
  • 单线程：程序只有一条执行路径。
  • 多线程：程序有多条执行路径。

2.2多线程的意义

多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。

理解：
我们的程序在运行的时候，都是在抢CPU的资源（执行权）。

  • 多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
  • 也就是说CPU在多线程程序中执行的时间要比单线程多，所以提高了程序的使用率。
  • 我们不能保证哪一个线程能够在哪个时刻抢到，所以线程的执行具有随机性。

2.4、线程的创建

  1. 通过继承Thread类创建
public class ThreadTest extends Thread{
    //创建线程方式一： 继承Thread类，   重写run方法   调用start开启
    //run方法 线程
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            System.out.println("我是run方法"+j);
        }
    }
    public static void main(String[] args) {
        //main线程，是主线程
        //创建一个线程对象
        ThreadTest test = new ThreadTest();
        //调用run方法
        //test.run();//就先执行run线程，再执行main主线程
        //调用start方法   开启线程   线程不一定立即执行，由CPU调度安排
        test.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}
  1. 实现Runnable接口创建
//创建线程方式二：实现runnable接口，重写run方法，执行线程放入runnable接口实现类，调用start方法
public class ThreadTest2 implements Runnable {

    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            System.out.println("我是run方法"+j);
        }
    }
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        ThreadTest2 Test2 = new ThreadTest2();
        //创建线程对象，通过线程对象来开启我们的线程,代理的意思
        Thread thread = new Thread(Test2);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}
  1. 实现Callable接口（了解）

总结：由于单继承的局限性，推荐使用实现Runnable接口创建线程，灵活方便，方便同一个对象对多个线程使用。
Thread类的基本获取和设置方法
public final String getName()//获取线程名称
public final void setName(String name)//设置线程名称
获取主线程方法：**public static Thread currentThread()**返回对当前正在执行的线程对象的引用。
案例：抢火车票

public class ThreadTest3 implements Runnable {
    //模拟买火车票的案例
    private int num =10;//火车票的数量
    @Override
    public void run() {
        while (true){
            if (num <= 0){//没票就退出
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"张票");
            //那个线程拿到了第几张票
        }
    }

    public static void main(String[] args) {
        ThreadTest3 test3 = new ThreadTest3();
        //创建三个线程对象
        new Thread(test3,"小芳").start();
        new Thread(test3,"公司张总").start();
        new Thread(test3,"黄牛党").start();
    }
}

案例：龟兔赛跑

//模拟龟兔赛跑
public class ThreadTest4 implements Runnable {
    private static String winner;//定义一个胜利者，并且唯一
    @Override
    public void run() {
        //设定距离是100步
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean b = gameover(i);
            //如果比赛结束了，就停止比赛
            if (b){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    public boolean gameover(int steps){
        //判断是否有胜利者
        if (winner != null){
            return true;
        }else{
            if (steps >=100){
                winner = Thread.currentThread().getName();
                System.out.println("胜利者是："+winner);
                return true;
            }else {
                return false;
            }
        }
    }
    public static void main(String[] args) {
        ThreadTest4 test4 = new ThreadTest4();
        //创建兔子线程和乌龟线程
        new Thread(test4,"兔子").start();
        new Thread(test4,"乌龟").start();
    }
}

3、静态代理模式

比如你要结婚，找婚庆公司帮你布置现场等。
真是对象和代理对象都要实现同一个类。
代理对象要代理真是角色。
代理的好处：

  • 代理对象可以做很多真是对象做不了的事
  • 真是对象专注于做自己的事

4、Lambda表达式

Lambda表达式使代码变得简洁，避免了内部类定义过多，去掉了一堆没用意义的代码。

函数式接口

任何一个接口，如果里面只有唯一一个抽象方法，这就是一个函数式接口。
函数式接口，我们可以通过lambda表达式来创建该接口对象。

- 正常代码：

public class LambdaTest {
    public static void main(String[] args) {
        Like a = new a();
        a.like(20);
    }
}
//创建一个函数式接口
interface Like{
    void like(int a);
}
//创建实现类
class a implements Like{
    @Override
    public void like(int a) {
        System.out.println("我喜欢你了"+a+"天");
    }
}
  • lambda表达式：
public class LambdaTest2 {
    public static void main(String[] args) {
        Like2 love =null;
        love=(int a)-> {
            System.out.println("我喜欢你了"+a+"天");
        };
        love.like2(30);
    }
}
interface Like2{
    void like2(int a);
}

5、线程的五大状态

新生状态：Thread thread = new Thread()创建后,线程对象就进入了新生状态
就绪状态：当线程调用start()方法后，线程就进入录入就绪状态，但不一定立即执行，等待CPU调度
运行状态：进入运行状态，线程才真正开始运行
阻塞状态：当调用sleep()方法、wait时，线程进入阻塞状态，线程不运行，阻塞事件解除后，重新进入就绪状态，等待CPU调度
死亡状态：线程中断或结束的意思。线程一旦进入死亡状态，就不能再次启动

6、线程方法

停止线程

public class ThreadStop implements Runnable{
    public static void main(String[] args) {
        ThreadStop threadstop = new ThreadStop();
        new Thread(threadstop).start();
        for (int j = 0; j < 1000; j++) {
            System.out.println("main线程"+j);
            if (j==900){
                //4、调用stop方法，切换标志位，停止线程
                threadstop.stop();
                System.out.println("线程停止了");
            }
        }
    }
    //1、在线程中定义一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        //2、线程体使用标志位
        int i =0;
        while (flag){
            System.out.println("run线程"+i++);
        }
    }
    //3、这只一个方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }
}

线程休眠

slee(时间)方法：指定当前线程阻塞的毫秒数
sleep时间完成后线程进图就绪状态
每个对象都有一个锁，sleep不会释放锁
sleep方法可以放大问题的发生性

  • 模拟网络延时
public class ThreadSleep implements Runnable {
    //模拟买火车票的案例
    private int num =10;//火车票的数量

    @Override
    public void run() {
        while (true){
            if (num <= 0){//没票就退出
                break;
            }
            //模拟网络延时
            try {
                Thread.sleep(10);//休眠10毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"张票");
            //那个线程拿到了第几张票
        }
    }
    public static void main(String[] args) {
        ThreadSleep test3 = new ThreadSleep();
        //创建三个线程对象
        new Thread(test3,"小芳").start();
        new Thread(test3,"公司张总").start();
        new Thread(test3,"黄牛党").start();
    }
}
  • 模拟倒计时
//模拟倒计时
public class ThreadSleep2 {
    public static void main(String[] args) throws InterruptedException {
        tenDown();
    }
    //创建一个倒计时方法
    public static void tenDown() throws InterruptedException {
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <=0){
                break;
            }
        }
    }
}
  • 打印系统当前时间
public class ThreadSleep3 {
    public static void main(String[] args) throws InterruptedException {
        //打印系统当前时间
        Date date = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));//打印当前时间
            date = new Date(System.currentTimeMillis());//更新当前时间
        }
    }
}

线程礼让

线程礼让：让当前正在执行的线程暂停，但不阻塞。
礼让不一定成功，看CPU调度。

public class ThreadYield {
    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()+"线程结束了");
    }
}

线程强制执行（join）

join合并线程，待此线程执行完毕后，再执行其他线程。
与生活中买火车票插队一个意思。

//测试join  
public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("线程老大来了"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
        thread.start();
        for (int j = 0; j < 500; j++) {
            if (j == 200){
                thread.join();//插队
            }
            System.out.println("main线程"+j);
        }
    }
}

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来调度线程执行。
线程的优先级用数字表示，范围是：1~10
Thread.MAX_PRIORITY=10
Thread.MIN_PRIORITY=1
Thread.NORM_PRIORITY=5
获取线程的优先级：getPriority();
设置线程优先级：setPriority（int XXX）

public class ThreadPriority {
    public static void main(String[] args) {
        //打印主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "===" + Thread.currentThread().getPriority());
        //创建线程对象
        MyPriority myPriority = new MyPriority();
        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);
        //设置优先级  先设置，后启动
        thread1.start();
        thread2.setPriority(1);
        thread2.start();
        thread3.setPriority(8);
        thread3.start();
        thread4.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY 最高优先级 10
        thread4.start();
        thread5.setPriority(4);
        thread5.start();
    }
}
class MyPriority implements Runnable {
    @Override
    public void run() {
        //打印线程的名字和线程的优先级
        System.out.println(Thread.currentThread().getName() + "===" + Thread.currentThread().getPriority());
    }
}

守护线程（daemon）

分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
tg.setDaemon(true);设置守护线程。默认是false，表示用户线程，证常的都是用户线程，当传入true时，变为守护线程

//守护线程
//比如上帝守护你
public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread tg = new Thread(god);
        //设置守护线程   默认是false，表示用户线程，证常的都是用户线程，当传入true时，变为守护线程
        tg.setDaemon(true);
        tg.start();//守护线程启动
        new Thread(you).start();
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        System.out.println("上帝守护着众生");
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 30000; i++) {
            System.out.println("自己开心的活着");
        }
        System.out.println("goodbye world");
    }
}

7、线程同步

多个线程同步同一个资源。
并发：同一个对象被多个线程同时操作。
线程同步形成的条件：队列+锁。比如：排队上厕所，厕所门上有锁，为了保证安全性。

锁机制 synchronize

有一张票，三个人去买，如果都卖到了票，就会出现负数。所以引入了synchronize关键字，确保数据的正确性。
一个线程有锁会导致其他所有需要此锁的线程等待。
加锁会影响性能。
优先级高的线程等待优先级低的线程释放锁，会导致优先级导致，引起性能问题。
synchronize的两种用法：
锁的对象是变化的量，需要需改的

  • synchronize方法
    锁用在方法上，则锁的是调用者 this，而不是方法本身。
  • synchronize块

死锁

当多个线程都拿着对方需要的资源（锁），这就形成了死锁。
比如：有一个镜子和口红，两个女生都想化妆，一个女生先拿到了镜子，等口红。另一个女生先拿到了口红，等镜子。这就是死锁的意思。
产生死锁的额必要条件

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

Lock锁（同步锁）

JDK5.0提供

public  class TestLock implements Runnable{
    public static void main(String[] args) {
        TestLock lock = new TestLock();
        new Thread(lock).start();
        new Thread(lock).start();
        new Thread(lock).start();
    }
    int tickerNums =10;//定义车票数量
    private final ReentrantLock reentrantLock = new ReentrantLock();//定义lock锁
    @Override
    public void run() {
        while (true){
            try {
                reentrantLock.lock();//加锁
                if (tickerNums >0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票数"+tickerNums--);
                }else {
                    break;
                }
            }finally {
                reentrantLock.unlock();//解锁
            }
        }
    }
}

8、线程协作

应用场景：生产者和消费者问题
解决线程之间通信问题的方法：
wait();表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout);指定等待的毫秒数
notify();唤醒一个处于等待状态的线程
notifyAll();唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
解决方式

  1. 管程法
    在这里插入图片描述生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。
//测试生产者消费者问题   方法一：利用缓冲区解决，也就是管程法
//需要：生产者  消费者   产品  缓冲区
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 + "只鸡");
        }
    }
}
//产品
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;
    }
}
  1. 信号灯法
//信号灯法 标志位解决
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 < 10; i++) {
            if (i%2 == 0){
                this.tv.play("NBA");
            }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 < 10; i++) {
            this.tv.watch();
        }
    }
}

//产品    节目
class TV{
    //演员表演，观众等待  t
    //观众观看，演员等待  f
    String video;//表演的节目
    boolean flag= true;//设置一个标志位

    //表演
    public synchronized void play(String video){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演："+video);
        //通知观众观看
        this.notifyAll();
        this.video =video;
        this.flag= !this.flag;
    }
    //观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+video);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

9、线程池

Executors：工具类，用于创建并返回不同类型的线程池

public class TestPool {
    public static void main(String[] args) {
        //1、创建服务、创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);

        //执行
        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() {
        System.out.println(Thread.currentThread().getName());
    }
}
白了少年头yy
关注
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
多线程深入理解
qq_31539817的博客
06-04 345
一：线程概述 1，线程和进程 进程：正在运行的程序，是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存空间和系统资源。 线程：进程的执行单元，执行路径。 2，多线程和多进程的意义 多进程：提高CPU的使用率 多线程：提高应用程序的使用率 3，线程的生命周期 二：实现多线程 ...
【多线程与高并发】- synchronized锁的认知
qq_43843951的博客
02-19 23万+
synchronized 是 Java 语言的一个关键字，它允许多个线程同时访问共享的资源，以避免多线程编程中的竞争条件和死锁问题。
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 24万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
Java多线程
一个小小的码农
07-17 4550
多线程进程其他相关概念创建线程的两种方式为什么使用start（）方法而不直接使用run（）方法start（）方法底层继承Thread 和 实现Rnnable的区别售票系统SellTicket01类继承Thread实现SellTicket02类实现Runnable接口线程终止基本说明通知方式线程常用方法常用第一组注意事项和细节常用方法第二组案例常用方法第三组用户线程和守护线程线程的生命周期线程同步机制利用同步解决买票超卖问题互斥锁基本介绍注意事项和细节线程死锁释放锁练习题同步方法同步代码块 进程 1、进程是指
C语言多线程
微小冷的学习笔记
03-19 9060
在C语言中创建线程方式如下 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 其中，thread为线程指针；attr为线程属性，默认NULL；start_routine为线程运行函数起始地址；arg为运行函数的参数。无参数时使用NULL。 如果线程成功创建，函数返回0，否则说明创建失败。 当线程完成工作后，若无需继续存在，则会调用pthread_exit函数。也就是说，这个函数可以显式地退出一个线程。
Java 多线程：彻底搞懂线程池
孙强 Jimmy 的博客
07-09 19万+
熟悉Java多线程编程的同学都知道，当我们线程创建过多时，容易引发内存溢出，因此我们就有必要使用线程池的技术了。
多线程操作List
weixin_42740540的博客
07-15 4692
多线程
QSerialport多线程方法
《好好先生》专栏
05-20 7533
QSerialport多线程方法 使用Qt也已经有一段时间了，虽然使用过继承QThread重写run函数，以及继承QObject然后使用MoveToThread两种方法实现多线程，但是在QSerialPort的使用过程中，两种方法都存在一定的问题。 典型的问题： QObject: Cannot create children for a parent that is in a differe...
Java - 多线程
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
Java多线程（超详细）
loss_rose777的博客
08-14 2万+
25000字带你了解线程的概念，这一定是csdn上最全面的关于线程的文章，不看别后悔哦！
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
电动车上牌管理系统 SSM毕业设计 附带论文.zip
11-04
电动车上牌管理系统 SSM毕业设计 附带论文 启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B
tornado-6.1-cp39-cp39-manylinux2010_x86_64.whl
11-04
tornado-6.1-cp39-cp39-manylinux2010_x86_64.whl
【eclipse和idea两个版本运行源码】基于Java Swing +mysql 实现的网吧管理系统
最新发布
11-04
一、项目简介 本项目是一套基于Java Swing 开发的网吧管理系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 二、技术实现 ​后台技术：java swing ​数据库：MySQL ​数据库连接池：c3p0 三、系统主要功能 用户登录: 分为 普通用户和管理员 两种角色 菜单模块：上机，下机， 系统设置：管理员设置，会员设置，计费设置， 退出系统 管理模块：增加会员，删除会员，信息修改，信息查询 视图模块：主页视图，在线用户，统计视图， 统计报表模块：人数报表，收入报表 帮助模块：联系我们，关于系统 详见：https://blog.csdn.net/weixin_43860634/article/details/125247764
pc-dmis软件脚本-输出Excel格式报告
11-04
使用软件自带的basic脚本编辑制作的脚本 低版本软件无法输出Excel报告，可以通过脚本方式实现这一功能
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值