多线程（上篇）bing

最新推荐文章于 2024-09-30 10:36:33 发布
最新推荐文章于 2024-09-30 10:36:33 发布
阅读量198 收藏
点赞数 1
分类专栏： 多线程 文章标签： java 多线程 多进程 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiqipengcheng/article/details/117967752
版权

这里写目录标题

概念

任何计算机系统都包含一个基本的程序集合，称为操作系统（OS）。笼统的理解，操作系统包括：
内核（进程管理，内存管理，文件管理，驱动管理）
其他程序（例如函数库，shell程序等等）

内存 VS磁盘:
–内存一般比较小，磁盘比较大。
–造价不停，内存造价比较贵，磁盘便宜。
-内存是以纳秒级别读写速度、磁盘读写单位微秒;内存的操作速度比磁盘快很多。
一内存不能进行持久化，磁盘可以持久化。

多线程编程:
宏观上来看是同时执行的，而微观上来看是轮流执行的。
并发编程:所有程序轮流执行任务。
并行编程:所有程序同时执行任务。

进程组成:
1.PID
2.状态（新建、就绪、运行中、终止、阻塞)
3.优先级
4.一组指针（资源)
5.记账信息（解决资源分配不均的问题)
6.上下文(当没有时间片这时候需要保持状态等待下次执行，这个暂存状态和后面的运行状态就是一个上下文)

进程线程

进程VS线程;
1.进程是系统分配资源的最小单位;线程是系统调度的最小单位。
2.一个进程中可以包含多线程。
3.进程的实际执行单位就是线程。
4.一个进程里面至少包含一个线程，线程的存储必须依托于进程。
5.进程不可以共享资源，而线程可以共享资源（资源的是：1.打开的文件。2.内存）。
图示化：
在这里插入图片描述
主线程:主要执行业务的线程。
子线程:在主线程中创建线程就叫子线程。

Java线程

线程休眠方式

      // 方式一：线程休眠
            Thread.sleep(  1000);

           // 方式2：线程休眠
            TimeUnit.SECONDS.sleep(1); // 休眠 1 秒
           TimeUnit.HOURS.sleep(1); // 休眠 1 小时

        // 方式一3：线程休眠
        Thread.sleep(TimeUnit.SECONDS.toMillis(1));

线程的创建方式

第一种

写法1：

class MyThread extends Thread {
        @Override
        public void run() {
            // 写你的业务代码
            // 打印当前线程的名称
            System.out.println("子线程名称：" +
                    Thread.currentThread().getName());
        }
    }

写法2：

   Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("当前线程名称：" +
                        Thread.currentThread().getName());
            }
        };
        // 运行线程
        thread.start();
    }

这种创建方式的缺点:因为 Java语言的设计是单继承的，继承了Thread 类之后，就不能继承其他类。

第二种

写法1：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程名：" +
                Thread.currentThread().getName());
    }
}

public class ThreadDemo5 {


    public static void main(String[] args) {
        // 创建 Runnable 子对象
        MyRunnable myRunnable = new MyRunnable();
        // 创建线程
        Thread thread = new Thread(myRunnable);
        // 启动线程
        thread.start();
    }
}

写法2：

 public static void main(String[] args) {
        // 创建一个匿名 Runnable 类
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程：" +
                        Thread.currentThread().getName());
            }
        });
        thread.start();
    }

写法3：

  public static void main(String[] args) {
        // lambda + runnable
        Thread thread = new Thread(() -> {
            System.out.println("线程名：" +
                    Thread.currentThread().getName());
        });
        thread.start();
    }

该种写法只有在JDK1.8之上的支持。
当ideal使用lamdba出错时，需要将是用的JDK换成1.8
操作如下：
在这里插入图片描述
在这里插入图片描述

第三种
// 创建线程
    static class MyCallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            // 产生随机数
            int num = new Random().nextInt(10);
            System.out.println(String.format("线程：%s,生产了随机数：%d",
                    Thread.currentThread().getName(), num));
            return num;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1.创建 Callable 子对象
        MyCallable callable = new MyCallable();
        // 2.使用 FutrueTask 接收 Callable
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 3.创建线程并设置任务
        Thread thread = new Thread(futureTask);
        // 执行线程
        thread.start();
        // 得到线程的执行结果
        int num = futureTask.get();
        System.out.println("线程返回结果：" + num);
    }

线程创建的数量是不是越多越好?答:不是。
问题:创建多少线程合适?
答:要看实际的情况。
任务分为两种:
1.计算密集型任务;2.读写文件,
线程的数量=CPU核数最好;对于读写文件操作，理论上来讲线程数量越多越好。

线程的构造方法

Thread() 创建线程对象
Thread(Runnable target) 使用 Runnable 对象创建线程对象
Thread(String name) 创建线程对象，并命名
Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名
Thread(ThreadGroup group,Runnable target)线程可以被用来分组管理，分好的组即使线程组，这个目前我们了解即可

  public static void main(String[] args) {

        ThreadGroup threadGroup = new ThreadGroup("group1");

        Thread t1 = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    System.out.println("选手1达到终点了~");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1200);
                    System.out.println("选手2达到终点了~");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();

        // 等待所有人员到达终点
        while (threadGroup.activeCount() != 0) {
        }

        System.out.println("宣布比赛结果");
    }

Thread常见的属性

ID getId()
名称 getName()
状态 getState()
优先级 getPriority()（默认权重是5，是CPU执行权重，在1-10之间）
是否后台线程（守护线程） isDaemon()
是否存活 isAlive()
是否被中断 isInterrupted()

线程分类

1.用户线程（默认创建的线程就是用户线程)—线程类型:Daemon：false
2.守护线程（后台线程)
守护线程是为用户线程服务，当用户线程执行完成之后，守护线程会跟随用户线程一起结束。
守护线程是为用户线程服务。
守护线程的经典使用场景:垃圾回收器。

守护线程需要注意的事项:

1.守护线程的设置必须放在开启线程(start())之前。
2在守护线程中创建的线程默认就是守护线程。

run () 、start ()的区别 :

1.run()方法是一个对象的普通方法，它使用的是主线程来执行任务的。
2.start()是线程的开启方法，它使用新的线程来执行任务的。
3.start()方法只能执行一次，而run()可以调用n次。

线程中断方式

1.自定义全局标识来实现中断;

  // 全局变量
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            while (!flag) {
           
                try {
                    // 休眠线程
                    Thread.sleep(100);
                    System.out.println("我正在转账...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            System.out.println("啊？差点误了大事。");
        }, "张三");
        // 开启任务
        t1.start();

        // 休眠主线程一段时间
        Thread.sleep(310);

        // 终止线程
        System.out.println("停止交易，有内鬼.");
        flag = true;
    }

在这里插入图片描述

2.使用Thread的intrrupted来中断。
interrupt（）、interrupted（）和isInterrupted（）

  public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            while (!Thread.interrupted()) {
                try {
                    // 休眠线程
                    Thread.sleep(100);
                    System.out.println("我正在转账...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
            System.out.println("啊？差点误了大事。");
        }, "张三");
        // 开启任务
        t1.start();

        // 休眠主线程一段时间
        Thread.sleep(310);

        // 终止线程
        System.out.println("停止交易，有内鬼.");
        t1.interrupt();

    }

使用系统的 Intrruput() 可以及时的终止线程，而使用自定义全局变量终止线程的方式，比较温柔不能立刻终止。

join（）

public void join() 等待线程结束
public void join(long millis) 等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos) 同理，但可以更高精度

当前线程的引用

在这里插入图片描述

sleep（）

public static void sleep(long millis) throws InterruptedException 休眠当前线程 millis 毫秒
public static void sleep(long millis, int nanos) throws
InterruptedException 可以更高精度的休眠

查看线程的状态

   public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }

    }

在这里插入图片描述

yield（）

线程常用方法: yield【用来让出CPU的执行权】
yield分配执行权不一定成功，要看cpu的最终选择，但总体来说还是基本符合预期。

多线程问题:非线程安全

非线程安全:使用多线程执行任务，最终得到的结果和预期不一致。

线程不全的因素:

1.CPU是强制式执行的（万恶之源)（并不是一个执行完另一个在执行）。
2.通过操作的一个变量。
3.可见性
4.非原子性
5.编译器优化
3
在这里插入图片描述
volatile 禁止L1工作缓存的使用

在这里插入图片描述

public class Main {
    public static boolean flag = false;
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            while (!flag) {
                System.out.println("线程1");//它的存在与否会存在可见性和编译器优化的双重结果。
            }
            System.out.println("线程1执行结束");
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.print("->");
            scanner.nextInt();
            flag = true;
        });
        t2.start();

    }
}
如何解决
volatile

volatile总结: volatile可以解决内存不可见和指令重排序的问题，但是不能解决原子性问题。

 public static volatile boolean flag = false;

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            while (!flag) {
            }
            System.out.println("线程1执行结束");
        });
        t1.start();

        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.print("->");
            scanner.nextInt();
            flag = true;
        });
        t2.start();

    }

在这里插入图片描述

加锁操作:
1. synchronized ( jvm层的解决方案 ）可重入加锁

synchronized的底层是使用操作系统的mutex lock实现的。

当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内存中读取共享变量
synchronized用的锁是存在Java对象头里面的。
在这里插入图片描述
synchronized 实现分为:
1.操作系统层面，它是依靠互斥锁mutex.
2.针对.JVM，monitor 米实现。
3.针对Java语言来说，是将锁信息存放在对象头（标识，标识锁状态/锁的拥有者)

synchronized 的3种使用场景:
1.使用synchronized修饰代码块（可以给任意对象进行加锁)

 synchronized (ThreadDemo31.class) {//也可以是个对象
                        // 代码1
                        number++;
                    }

2.使用synchronized 来修饰静态方法（对当前的类进行加锁)

  // 全局变量
    private static int number = 0;
    // 循环次数
    private static final int maxSize = 100000;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                increment();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                decrement();
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终执行结果：" + number);

    }

    // 相加
    public synchronized static void increment() {
        for (int i = 0; i < maxSize; i++) {
            number++;
        }
    }

    // 相减
    public synchronized static void decrement() {
        for (int i = 0; i < maxSize; i++) {
            number--;
        }
    }

3.使用synchronized来修饰普通方法（对当前类实例进行加锁)

public class ThreadDemo {
    // 全局变量
    private static int number = 0;
    // 循环次数
    private static final int maxSize = 100000;

    public static void main(String[] args) throws InterruptedException {

        ThreadDemo threadDemo = new ThreadDemo();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadDemo.increment();
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadDemo.decrement();
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终执行结果：" + number);
    }

    // 相加
    public synchronized void increment() {
        for (int i = 0; i < maxSize; i++) {
            number++;
        }
    }

    // 相减
    public synchronized void decrement() {
        for (int i = 0; i < maxSize; i++) {
            number--;
        }
    }

}
  1. 手动锁Lock 的方式。
    在这里插入图片描述
    在这里插入图片描述
 // 全局变量
    private static int number = 0;
    // 循环次数
    private static final int maxSize = 100000;


    public static void main(String[] args) throws InterruptedException {

        ThreadDemo34 threadDemo33 = new ThreadDemo34();

        // 1.创建lock实例
        Lock lock = new ReentrantLock(true);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    // 2.加锁
                    lock.lock();
                    try {
                        // 业务操作
                        number++;
                    } finally {
                        // 3.释放锁
                        lock.unlock();
                    }
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < maxSize; i++) {
                    lock.lock();
                    try {
                        number--;
                    } finally {
                        lock.unlock();
                    }
                }
            }
        });
        t2.start();

        t1.join();
        t2.join();
        System.out.println("最终执行结果：" + number);
    }

操作锁的流程:
1.尝试获取锁
2.使用锁(这一步骤是具体业务)
3.释放锁

公平锁和非公平锁

非公平锁的性能更高。
公平锁调度:
1.一个线程释放锁。
2.（主动）唤醒“需要得到锁”的队列来得到锁。
非公平锁:当一个线程释放锁之后，另一个线程刚好执行到获取锁的代码就可以直接获取锁。

在Java语言中所有的锁的默认实现方式都是非公平锁。
synchronized是非公平锁。

ReentrantLock 默认是非公平锁，但也可以显示的声明为公平锁。
显示的声明公平锁:
在这里插入图片描述

  public static synchronized  void main(String[] args) throws InterruptedException {
        Lock lock=new ReentrantLock(true);
Runnable runnable=new Runnable() {
    @Override
    public void run() {
        for(char a:"abcd".toCharArray()){
            lock.lock();
            try{
                System.out.println(a);
            }
            finally {
                lock.unlock();
            }
        }
    }
};
Thread a=new Thread(runnable);
        Thread b=new Thread(runnable);
        Thread.sleep(100);
        a.start();
        b.start();

    }

synchronized 和Lock 的区别:

1…synchronized自定进行加锁和释放锁，而Lock 需要手动加锁和解锁。
2.Lock 是 Java 层面的锁的实现，而synchronized 是JVM层面的实现。
3.synchronized 和 Lock 适用范围不同，Lock 只能用来修饰代码块，而synchronized既可以修饰代码块，又可以用来修饰静态方法和普通方法。
4.synchronized 锁的模式只有非公平锁模式，而 Lock 既可以使用公平锁的模式又可以使用非公平锁的模式。
5.Lock 的灵活性更高( tryLock )。
下一篇

月屯
关注
专栏目录
java多线程开发的可见性问题
天外水火的专栏
08-06 819
java多线程开发可见性问题在于多线程之间使用共享的变量，如果其他线程也在修改变量，因为执行顺序问题，在当前线程中不一定会得到真实的值，比如下面的代码，看看是否达到了可以修改共享变量，并且在线程中成功应用。 package test.commontest; public class TestThread { //共享变量flag public static Boolean ...
Java多线程超详解
qq_43751200的博客
05-13 345
Java多线程多线程的创建方式一：继承Thread类方式二：实现Runnable接口方式三：JDK 5.0新增：实现Callable接口创建线程三种方式对比Thread的常用方法线程安全线程安全问题是什么、发生的原因线程安全问题案例模拟线程同步同步思想概述方式一：使用synchronized的同步代码块方式二：使用synchronized的同步方法方式三：Lock锁线程通信线程池定时器并发、并行线程的生命周期 多线程的创建 方式一：继承Thread类 Thread类： Java是通过java.lang.Th
python多线程没用_Python多线程鸡年不鸡肋
weixin_39778214的博客
11-22 166
当初在刚学习python多线程时，上网搜索资料几乎都是一片倒的反应python没有真正意义上的多线程，python多线程就是鸡肋。当时不明所以，只是了解到python带有GIL解释器锁的概念，同一时刻只能有一个线程在运行，遇到IO操作才会释放切换。那么，python多线程是否真的很鸡肋呢？要解决这个疑惑，我想必须亲自动手测试。经过对比python与java的多线程测试，我发现python多线程的效...
死锁、线程bing
二月鸟
06-21 213
前言 定义:在两个或者两个以上的线程运行中，因为资源抢占而造成线程一直等待的问题。 检测工具：jconsole、jmc、jvisualvm 位置： JDK8\bin 造成死锁的4个条件: 死锁代码： 1.互斥条件:当资源被一个线程拥有之后，就不能被其它的线程拥有了。（不可更改） ⒉.请求拥有条件:当一个线程拥有了一个资源之后又试图请求另一个资源。（可以解决） 3.不可剥夺条件:当一个资源被一个线程拥有之后，如果不是这个线程主动释放此资源的情况下，其他线程不能拥有此资源。（不可更改） 4.环路等待条件:两个
多线程学习笔记
LLmf_828的博客
02-19 73
多线程学习笔记 这是一篇关于多线程相关的一些学习笔记 继承Thread类 1、子类继承Thread类具备多线程能力 2、启动线程: 子类对象. start() 3、不建议使用:避免OOP单继承局限性 //创建线程方式一：继承Thread类，重写run()方法，调用start开启线程 //总结：线程开启不是立即执行，由CPU调度。 public class TestThread1 extends Thread{ @Override public void run() {
ThreadLocal、单例模式、线程通讯bing
二月鸟
06-26 188
线程安全问题 场景：实现1000任务的时间格式化 private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss"); public static void main(String[] args) { // 定义线程池 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecu
python为什么没有真正意义上的多线程_Python 多线程鸡年不鸡肋
weixin_39608134的博客
12-06 106
原标题：Python 多线程鸡年不鸡肋
如何在多线程中使用JNI？
Trent1985的专栏
12-30 1414
如果你想了解JNI在如何在多线程下使用 如果你在子线程使用JNI时遇到findClass不能找到目标Class，而在主线程下却能找到该Class的问题。或是GetEnv返回NULL的问题 如果你想多学点编程技术的话 那么，这篇文章就是为你而写的， :) 最近工作中遇到这么个问题：c++代码需要调用Android的API来做一个比较耗时的任务，因为有点耗时，希望能有个进度条显示给用户，很
线程池bing
二月鸟
06-23 218
前言 线程缺点: 1.线程的创建它会开辟本地方法栈、虚拟机栈、程序计数器成线程私有的内存，同时消耗的时候需要销毁以上3个区域，因此频繁的创建和消耗比较消耗系统资源; 2.在任务量远远大于线程可以处理的任务量的时候，并不能友好拒绝任务。 线程池定义:使用池化技术来管理线程和使用线程的方式。 线程池的优点 1.可以避免频繁的创建和消耗线程。 2.可以更好的管理线程的个数和资源的个数。 3.拥有更多的功能，比如线程池可以进行定时任务的执行。 4.线程池可以更优化的拒绝不能处理的任务。 线程池的创建 线程池的创建总
CEF线程之multi_threaded_message_loop参数
新兴IT民工的专栏
12-28 1354
multi_threaded_message_loop的作用及其相关类的说明
〖程序员的自我修养 - 认知剖析篇③〗- 十大编程语言的优缺点
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
07-26 1万+
我们掌握不了所有的编程语言，但我们掌握的语言越多，在未来的发展与可塑性上就越强，就越容易受到企业的青睐，如果是作为自由开发者的话，也就越会有客户和开发团队与我们合作。 考虑到这一点，希望各位小伙伴能规划好自己的学习计划，并开始一一学习，以成为某一细分领域的技术专家或者某个蓬勃发展领域的顶级专家。
netty案例，netty4.1中级拓展篇三《Netty传输Java对象》
bugstack虫洞栈
08-22 1815
前言介绍 Netty在实际应用级开发中，有时候某些特定场景下会需要使用Java对象类型进行传输，但是如果使用Java本身序列化进行传输，那么对性能的损耗比较大。为此我们需要借助protostuff-core的工具包将对象以二进制形式传输并做编码解码处理。与直接使用protobuf二进制传输方式不同，这里不需要定义proto文件，而是需要实现对象类型编码解码器，用以传输自定义Java对象。 pro...
Android面试题整理（源自鸿洋大神公众号【201803】的一篇BAT面试题推送）
唯爱丶卡卡西的博客
04-13 1735
三月，想必各位程序员GG 此刻想要的，莫过于一篇面试宝典。鄙人不才，也从未系统的刷过面试题，以鸿洋大哥一篇面试题为引，略加整理，希望能帮到各位不知道看什么小伙伴。（大部分知识都是有答案的）. 原文链接: [https://mp.weixin.qq.com/s/p3l9wr4DX976Lr62-dYe8w(只有题)] PS：其实在推送2天后就已经全部 总结出来了，只是新的CSDN 编辑器排版不会...
netty案例，netty4.1中级拓展篇一《Netty与SpringBoot整合》
bugstack虫洞栈
08-22 2282
前言介绍 在实际的开发中，我们需要对netty服务进行更多的操作，包括；获取它的状态信息、启动/停止、对客户端用户强制下线等等，为此我们需要把netty服务加入到web系统中，那么本章节介绍如何将Netty与SpringBoot整合。 Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使...
工厂模式的介绍及实现
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
java将word转pdf
紫月7575的博客
09-30 243
java将word转pdf
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 295
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 377
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
Linux多线程编程详解：pthread实践与指南
- Linux的POSIX线程库（pthread）是用于实现多线程功能的标准API，它允许开发者在Linux平台上编写跨平台的多线程代码。 2. **主要内容** - **线程基础**：讨论了线程的概念，包括线程的生命周期、状态转换以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

月屯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值