多线程

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

多线程

多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”

创建一个多线程

第一种创建方法

package com.demo1.stage1;
/**
* 创建多线程方式一：
* 1，创建一个继承Thread的子类
* 2，重写run方法
 * 3,创建Thread类的子类的对象
 * 4，通过此类对象调用start()*/
public class Main {
    public static void main(String[] args) {
        //创建子类对象
        Demo1 demo1 = new Demo1();
       //调用start方法：1，启动当前线程；2,，调用当前线程的run方法
        demo1.start();
    }
}

class Demo1 extends Thread{
    //重写Thread的run方法
    @Override
    public void run() {
        for(int i = 0; i<100; i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

注意：一个子类对象只能有调用一次start（）方法，如果想再调用需要再次创建一个新的子类对象。

第二种创建方法

package com.demo1.stage1;
/**
 * 创建多线程方式二：
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 * */
public class Demo3 {
    public static void main(String[] args) {
        //3.创建实例对象
        Mytest2 mytest2 = new Mytest2();
        //4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
        Thread thread = new Thread(mytest2);
        //5.通过Thread类的对象调用start()方法：启动线程，调用当前线程的run()方法，》调用了Runnable类型的target的run()方法
        thread.start();
    }
}
//1.创建一个实现了Runnable接口的类
class Mytest2 implements Runnable{
    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for(int i = 0; i<100; i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

线程常用的方法

  1. start()：启动当前线程；调用当前线程的run()
  2. run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
  3. currentThread()：静态方法，返回执行当前代码的线程
  4. getName()：获取当前线程的名字
  5. setNmae()：设置当前线程的名字
  6. yield()：释放当前cpu的执行权
  7. join()：在线程a中调用线程b的join()，此前线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
  8. stop()：强制结束线程生命期，不建议使用
  9. sleep(long millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，线程是阻塞状态。
  10. isAlive()：判断当前线程是否存活。

线程的名称获取和设置

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread,"线程1");//设置线程名字
        thread.start();
        System.out.println(Thread.currentThread().getName()+"正在执行");//获取当前正在执行的线程名字
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行");//获取当前正在执行的线程名字
    }

线程的休眠

Thread.sleep(1000);//休眠1秒

线程中断

结束线程时，为了安全不能直接调用stop()，外部掐死线程会造成资源不能释放，并且会产生内存垃圾，一个线程是否关闭，应该由线程本身决定。

那么怎么操作来进行线程的中断呢？

可以使用线程的interrupt()方法标记线程在何时何处进行关闭，先观察以下代码：

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread,"线程1");//设置线程名字
        thread.start();
        System.out.println(Thread.currentThread().getName()+"正在执行");//获取线程名字
        thread.interrupt();//标记线程中断
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                //当程序运行到线程中断的标记处，就会直接跳转到该处
                System.out.println("程序已关闭");
                return;//关闭此方法
            }
            System.out.println(Thread.currentThread().getName()+"正在执行");
        }

    }
}

当程序运行到 thread.interrupt()；时，该线程就会自动执行 catch（）块的代码，在此代码块中，可以用return来关闭方法从而中断线程。

守护线程

线程.setDaemon(true) 将该线程标记为守护线程，当用户线程结束时，所有标记为守护线程的线程都死亡

public class Demo3 {
    public static void main(String[] args) {
        //3.创建实例对象
        Mytest2 mytest2 = new Mytest2();
        //4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象
        Thread thread = new Thread(mytest2);
        //5.通过Thread类的对象调用start()方法：启动线程，调用当前线程的run()方法，》调用了Runnable类型的target的run()方法
        thread.setDaemon(true);//设置守护线程，当用户线程结束时，所有的线程死亡
        thread.start();
    }
}
//1.创建一个实现了Runnable接口的类
class Mytest2 implements Runnable{
    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for(int i = 0; i<100; i++){
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

线程安全问题

以卖票为例，观察以下代码

public class Demo2 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread window1 = new Thread(myThread2, "窗口1");
        Thread window2 = new Thread(myThread2, "窗口2");
        Thread window3 = new Thread(myThread2, "窗口3");
        window1.start();
        window2.start();
        window3.start();
    }
}
class MyThread2 implements Runnable{
    private int num=10;
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            if(num>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"出票成功！余票为："+num);
            }else {
                return;
            }
        }
    }
}

输出结果：
在这里插入图片描述
看代码，在MyThread类中，明明规定有num大于零的条件才去执行售票的代码，但是输出的结果却出现了负值，这是怎么回事呢？

原来，在这三条线程中，因为执行的代码存在时间差，比如，当num=1时，窗口1的线程判断num是大于零的，于是执行了下面的代码，但是num–的代码还没来得及执行，这一时刻num还是等于1，而窗口2和窗口3接收到的num还是1，满足运行条件，而窗口1的线程执行num–时，数值变为0，窗口2窗口3的线程也继续执行num–，于是就出现了负值。

这就出现了线程安全的问题

解决方案一：同步代码块

同步可理解线程排队机制。

格式：synchronize(锁对象){执行的代码} java的所有对象都可以往里面传。

例如：

class MyThread2 implements Runnable{
    private int num=10;
    private Object o=new Object();
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            synchronized (o){//同步代码块
                if(num>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                    System.out.println(Thread.currentThread().getName()+"出票成功！余票为："+num);
                }else {
                    return;
                }
            }
        }
    }
}

这里传入了一个Object的对象，三条线程同时看管着这个锁，当一条线程执行该锁下的代码时，其他线程需要等待执行的完成，释放锁后，其他线程才去争抢执行。

注意，锁对象必须在run()方法外部创建，作为大家共有的对象。

解决方案二：同步方法

与同步代码块的不同的是，同步方法是以方法为单位的加锁，而同步代码块比较细，可以以一行代码加锁。

做法很简单，就是将synchronize修饰到方法中

class MyThread2 implements Runnable{
    private int num=10;
    @Override
    public void run() {
      while (true){
          boolean a=sale();
      }
    }
    public synchronized boolean sale(){//同步方法，修饰到方法中
        if(num>0){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"出票成功！余票为："+num);
            return true;
        }else {
            return false;
        }
    }
}

注意：当同时有同步方法和同步代码块或者多个同步方法时，只执行同步代码块或只执行一个同步方法，因为多个线程只看管同一个锁。

解决方案三：显式锁Lock

前面的同步代码块和同步方法都属于隐式锁

显示锁为Lock类，实现类有ReentrantLock，Condition，ReadWriteLock。

实现的方式如下：

class MyThread2 implements Runnable{
    private int num=10;
    //显式锁
    Lock lock=new ReentrantLock();
    @Override
    public void run() {
      while (true){
          lock.lock();//锁
          if(num>0){
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              num--;
              System.out.println(Thread.currentThread().getName()+"出票成功！余票为："+num);
          }else {
              return;
          }
          lock.unlock();//解锁
       }
    }
}

公平锁和非公平锁

公平锁：多个线程执行时需要排队，先到先得。

非公平锁：多个线程争相抢夺，谁抢到谁执行，以上三种方案都为非公平锁

定义方式如下：

//显式锁 true:为公平锁 false：为不公平锁
Lock lock=new ReentrantLock(true);

线程死锁

线程a等线程b，线程b等线程a = 线程死锁

观察下面的代码：

/**
 * 死锁
 * @author 风亦未止
 */
public class Demo3 {
    public static void main(String[] args) {
        Criminal criminal = new Criminal();
        Police police = new Police();
        Thread thread = new Thread(new MyThread3(criminal, police));
        thread.start();
        criminal.say(police);
    }

}
//线程
class MyThread3 implements Runnable{
    Criminal criminal;
    Police police;

    public MyThread3(Criminal criminal, Police police) {
        this.criminal = criminal;
        this.police = police;
    }
    
    @Override
    public void run() {
        police.say(criminal);
    }
}

//罪犯
class Criminal{
    public synchronized void say(Police p){
        System.out.println("罪犯：你放了我，我就放了人质");
        p.fun();
    }
    public synchronized void fun(){
        System.out.println("人质放了人，也逃走了");
    }

}
//警察
class Police{
    public synchronized void say(Criminal c){
        System.out.println("警察：你放人质，我就放了你");
        c.fun();
    }
    public synchronized void fun(){
        System.out.println("警察救了人，罪犯逃走了");
    }

}

输出结果：
在这里插入图片描述

现在，两个线程死锁了，fun()方法没能够执行。

分析：创建的线程调用 police.say(criminal); 主线程调用criminal.say(police);。两个线程相互等待对方将锁释放，造成的死锁。

多线程通讯问题

假设：有厨师，服务员；服务员需要等待厨师炒完菜后才能上菜，观察下面代码：

/**
 * 厨师与服务员
 * @author 风亦未止
 */
public class Demo4 {
    public static void main(String[] args) {
        Food food = new Food();
        Waiter waiter = new Waiter(food);
        Cook cook = new Cook(food);
        Thread thread = new Thread(cook);
        Thread thread1 = new Thread(waiter);
        thread.start();
        thread1.start();
    }
    //厨师
   static class Cook implements Runnable{
        private Food food;

        public Cook(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 class Waiter implements Runnable{
        private Food food;

        public Waiter(Food food) {
            this.food = food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                food.get();
            }
        }
    }
    //菜
   static class Food{
        private String name;
        private String taste;
        public void setNameAndTaste(String name, String taste){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.name=name;
            this.taste=taste;
            System.out.println("厨师做了菜："+name+","+taste);
        }
        public void get(){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("服务员拿到了菜："+name+","+taste);
        }
    }

}

运行后会发现，红烧牛肉居然出现了柠檬味，或者厨师做了两个菜，服务员只端上一份菜的情况。分析：前者出现的原因是，厨师刚设置了菜名时，菜名就被服务员拿走了。从而导致错乱。

代码修改后：

/**
 * 厨师与服务员
 * @author 风亦未止
 */
public class Demo4 {
    public static void main(String[] args) {
        Food food = new Food();
        Waiter waiter = new Waiter(food);
        Cook cook = new Cook(food);
        Thread thread = new Thread(cook);
        Thread thread1 = new Thread(waiter);
        thread.start();
        thread1.start();
    }
    //厨师
   static class Cook implements Runnable{
        private Food food;
        public Cook(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 class Waiter implements Runnable{
        private Food food;
        public Waiter(Food food) {
            this.food = food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                food.get();
            }
        }
    }
   static class Food{
        private String name;
        private String taste;
        boolean flag=true;
        public synchronized void setNameAndTaste(String name, String taste){
            if (flag) {
                this.name=name;
                this.taste=taste;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("厨师做了菜：" + name + "," + taste);
                flag=false;
                this.notifyAll();//唤醒当前所有的线程
                try {
                    this.wait();//当前线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            if (!flag) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("服务员拿到了菜：" + name + "," + taste);
                flag=true;
                this.notifyAll();//唤醒当前所有的线程
                try {
                    this.wait();//当前线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

线程的六种状态

在这里插入图片描述

线程刚被创建时，处在NEW状态。
在这里插入图片描述

不论如何，最终线程都会走向死亡。

带返回值特殊的线程创建

Callable接口

class MyThread implements Callable<V>

Callable使用步骤

  1. 编写实现Callable接口，实现call方法

    class MyThread5 implements Callable<V>{
    @Override
    public V call() throws Exception {
        return null;
    }
}

  2. 创建FutureTask对象，并传入第一步编写的Callable对象

    MyThread5 myThread5 = new MyThread5();
FutureTask futureTask = new FutureTask<>(myThread5);

  3. 通过Thread，启动线程

    Thread thread = new Thread(futureTask);
thread.start();

可以通过get()方法获取返回值；isDone()方法：判断方法是否执行完毕；cancel()方法：结束线程

线程池Executors

顾名思义，就是专门装入线程的池子。有时候我们需要创建大量的线程，比如一万个线程，正常情况下，就会频繁的创建和结束各个线程，这会大大降低系统的效率。如果使用线程池，可以容纳多个线程，池中的线程可以反复使用，省去了频繁创建线程对象的操作对象，节省了大量的时间和资源。

线程池的好处

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

java中的四种线程池

1.缓存线程池

/**
 * 缓存线程池（长度无限制）
 * 执行流程：
 *      1.判断线程池是否存在空闲线程
 *      2.存在则使用
 *      3.不存在，则创建线程，并放入线程池，然后使用
 * @author 风亦未止
 */
public class Demo5 {
    public static void main(String[] args) {
        //创建线程池
        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());
            }
        });
    }   
}

2.定长线程池

/**定长线程池。(长度是指定的数值)
 * 任务加入后的执行流程：
 *      1.判断线程池是否存在空闲线程
 *      2.存在则使用
 *      3.不存在空闲线程，且线程池未满的情况下，则创建线程 并放入线程池，然后使用
 *      4,。不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程
 * @author 风亦未止
 */
public class Demo6 {
    public static void main(String[] args) {
        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());
            }
        });
    }
}

在这里插入图片描述

3.单线程线程池

/**
 * 单线程线程池。
 * 执行流程：
 *      1.判断线程池的那个线程是否空闲
 *      2.空闲则使用
 *      3.不空闲，则等待池中的单个线程空闲后使用
 * @author 风亦未止
 */
public class Demo7 {
    public static void main(String[] args) {
        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());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

线程任务执行完不会自动关闭，此时会等待执行任务，但长时间不执行会自动关闭

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

/**周期任务 定长线程池
 * 执行流程：
 *      1.判断线程池是否存在空闲线程
 *      2.存在则使用
 *      3.不存在空闲线程池，且线程池未满的情况下，则创建线程并冉福线程池，然后使用
 *      4.不存在空闲线程池，且线程池已满的情况下，则等待线程池存在空闲线程
 *
 * 周期性任务执行时：
 *      定时执行，当某个时机触发时，自动执行某任务
 * @author 风亦未止
 */
public class Demo8 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1 .定时执行一次
         * 参数1.定时执行的任务
         * 参数2.时长数字
         * 参数3.时长数字的时间单位，TimeUnit的常量
         *
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },5, TimeUnit.SECONDS);


        /**
         * 周期执行任务
         * 参数1. 任务
         * 参数2. 延迟时长数字（第一次执行在什么时间后）
         * 参数3.周期时长数字（每隔多久执行一次）
         * 参数4.时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        },5,1,TimeUnit.SECONDS);
    }
}

Lambda表达式

/**
 * Lambda表达式
 * 函数式编程思想
 *  而面向对象：创建对象调用方法解决问题
 *
 * @author 风亦未止
 */
public class Demo9 {
    public static void main(String[] args) {
        //匿名对象
       Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("输出一个结果");
            }
        });
       thread.start();

       //使用Lambda表达式，与上面的效果是一样的
        Thread thread1 = new Thread(() -> System.out.println("输出一个结果"));
        thread1.start();
    }
}

自定义一个：

public class Demo9 {
    public static void main(String[] args) {
        print(new MyMath() {
            @Override
            public int sum(int a, int b) {
                return a+b;
            }
        },100,200);

        //使用Lambda表达式
        //只保留接口参数和抽象方法体，并用->隔开
        print((int a,int b) -> {
            return a+b;
        },200,200);
    }
    public static void print(MyMath myMath,int a ,int b){
        int num=myMath.sum(a,b);
        System.out.println(num);

    }
        interface MyMath{
        int sum(int a,int b);
    }
}
风亦未止
关注
专栏目录
多线程 加锁
Sarah_212的博客
09-24 3878
线程同步 对多线程来说，资源是共享的，基本上不存在不允许访问的情况，但是，共享的资源在某一时间点只能有一个线程占用，所以需要给资源加锁。 线程的锁的种类 互斥锁 读写锁 条件变量 自旋锁 信号灯 互斥锁 互斥锁机制是同一时刻只允许一个线程占有共享的资源。 初始化锁 intpthread_mutex_init(pthread_mutex_t*mutex,constpthread_mutex_attr_t*mutexattr); 参数 mutexattr 用于指定锁的属性（见下）...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
多线程实操二：切菜，炒菜，上菜问题
qq_43193797的博客
04-05 485
问题描述： 有一家餐馆 餐馆里有三个厨师 一个负责切菜、一个负责炒菜、一个负责端菜 三个厨师出10道菜 顺序必须是：先切再炒再端 这个问题涉及到线程的定制化通讯 线程定制化通讯 public class Cooking { public String status = "cut"; Lock lock = new ReentrantLock(); ...
【多线程】小二上菜经典案例详解线程通信技术
numbbe的博客
01-27 496
目录场景 场景 厨师，顾客，小二。 厨师和顾客两个线程任务是有关系的。 顾客来了，点了鱼香肉丝，厨师就做鱼香肉丝。 顾客没来，厨师就等待。 厨师（线程任务类） 1、等顾客。 2、做菜。 3、通知小二上菜。 顾客（线程任务类） 1、上门。 2、等菜。 3、吃菜。 4、通知小二报菜。 ...
【算法】二进制中1的个数
adminzzk的博客
09-15 144
题目：请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。 例: 9的二进制表示为1001，有2位是1 解法一：思路：用1从右到左比对二进制上的每一位，&运算为1的做计数。 public static int oneNum(int num){ int count=0; for (int j = 1; j <=32; j++) { if ((num&(1<<j))==(1<<j)){
Python多线程详解
热门推荐
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
C#多线程详解
世界既不黑也不白，而是一道精致的灰。
08-11 3139
上下文切换（Context Switching）是多线程环境中的一种操作，指的是在一个 CPU 核心上切换正在执行的线程，从当前线程的执行上下文（包括寄存器状态、程序计数器等）切换到另一个线程的执行上下文, 线程的切换需要额外的开销，因此在某些情况下，过多的线程可能会导致性能下降。因此，在设计多线程应用程序时，需要考虑如何减少上下文切换的发生，以提高程序的执行效率。是用于实现线程同步的一种机制，用于保护共享资源，避免竞态条件。上下文切换开销指的是从一个线程切换到另一个线程的过程中所涉及的时间和资源开销。
C++多线程
weixin_43229348的博客
04-17 3323
1.基础知识 为了提高CPU的使用率，将某些需要耗时较多的任务或是大量IO操作（IO处理速度很慢），采用多线程可以适当的提高程序的执行效率。 C++11之后有了std::thread库，需要引入头文件： 先来介绍Thread的成员函数： # 用来查看当前线程的id thread::get_id() # 检查此线程是否还和主线程连接（已经完成join、detach的线程都是false） thread：：joinable() # 将线程与主线程的连接切断，并且此线程会继续独立执行下去，直到执行结束时候释放分配的
多线程编程
idpangpengcheng的博客
11-16 5715
多线程编程
C# 异步 多线程
wokao253615105的专栏
02-24 4744
转载自https://www.cnblogs.com/doforfuture/p/6293926.html C#中 Thread，Task，Async/Await，IAsyncResult 的那些事儿！ 说起异步，Thread，Task，async/await，IAsyncResult 这些东西肯定是绕不开的，今天就来依次聊聊他们 ...
创建多线程（8种方式）
qq_1757537040的博客
03-29 9471
无论有多少种形式，创建多线程的真正的方法， 其实只有两种： > 继承 Thread 类 > 实现 Runnable 接口 其它形式都是这两种方式的变体。 1、继承 Thread 类 ①实现方式 第一步：继承 Thread 类 第二步：重写 run() 方法 第三步：创建 Thread 子类对象 第四步：调用 start() 方法启动线程 ②start() 方法和 run() 方法区别 调用 run() 方法仅仅只是调用了一个子类中重写的父类...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Java企业面试题3
m0_74972727的博客
09-15 881
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 184
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 519
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 174
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 905
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值