fufu笔记之多线程

最新推荐文章于 2024-07-07 19:49:14 发布
最新推荐文章于 2024-07-07 19:49:14 发布
阅读量193 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47953855/article/details/110201187
版权

1.多线程概述

进程：App，一个类文件

线程：App的功能，类里的一个方法

2线程的核心概念

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

2.1线程的三种创建方式

  1. 继承Thread类(重点)

    class Test1 extends Thread{
    //重写Thread类的run方法
    @ov
    public void run(){
        //重写的方法体
    }
}

  2. 实现Runnable接口（重点）

    Runnable接口是一个函数式接口，只有一个run方法

    class Test2 implements Runnable{
    //实现Runnable接口的run方法
    public void run(){
        //重写的方法体
    }
}

  3. 实现Callable接口（了解）

    /*
* 实现callable接口创建多线程
* */
public class MyFirstCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 200; i++) {
            System.out.println("我要记单词"+i);
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyFirstCallable call = new MyFirstCallable();
        //创建执行服务
        ExecutorService ser  = Executors.newFixedThreadPool(3);
        //提交请求
        Future<Boolean> result1 = ser.submit(call);
        //获取结果
        boolean b =  result1.get();
        //关闭服务
        ser.shutdownNow();
    }
}

2.2初识多线程迸发

当多个线程同时操作同一个对象时，线程不安全，数据紊乱

public class ThreadBurst implements Runnable {
    private int stack = 10;
    @Override
    public void run() {
        while(stack>0){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread()：当前Thread, getName:获取线程name
            System.out.println(Thread.currentThread().getName()+"抢到了第"+(stack--)+"张票");
        }
    }

    public static void main(String[] args) {
        ThreadBurst tb1 = new ThreadBurst();
        new Thread(tb1,"线程1").start();
        new Thread(tb1,"线程2").start();
        new Thread(tb1,"线程3").start();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k8WqneYP-1606389313117)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201110142656696.png)]

可以看到，在while循环stack不小于0的情况下，线程1，2分别抢到了第0和第-1张票，数据发生了紊乱

3.Lamda表达式

3.1 函数式接口

**定义：**任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

**作用：**避免匿名内部类定义过多

**实质：**函数式编程

//函数式接口
public interface Runnable{
	public abstract void run();
}

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

  //lamda表达式
        la = (int a) ->{
            System.out.println("我是lamda表达式"+a);
        };
        la.show(2);

 //简化lamda表达式
        la = (a) ->{
            System.out.println("我是简化之后的lamda表达式"+a);
        };
        la.show(3);

 //简化括号 //这里a的数据类型取决于函数接口里的数据类型
        la = a ->{
            System.out.println("我是继续简化之后的lamda表达式"+a);
        };
        la.show(4);

 //当只有一条语句的时候，大括号也能省略
        la = a -> System.out.println("一条数据语句全部省略"+a);
        la.show(5);

3.2 匿名内部类

外部类 ——> 静态内部类 ——> 匿名内部类——>Lamda表达式——>简化Lamda表达式

匿名内部类没有类名，无法创建对象，也无法继承，

package com.hsf.JavaSE.Test;

public class Test1 {
    public static void main(String[] args) {

        //匿名内部类：必须通过接口或父类来实现创建
        La la = new La(){
            @Override
            public void show() {
                System.out.println();
            }
        };
    }
}

//函数式接口
interface La{
    public abstract void show();
}

4.静态代理

**静态代理模式：**真实对象和代理对象都要实现同一个接口，代理对象要代理真实对象

package com.hsf.JavaSE.Thread;

//测试类
public class StaticProxy {
    public static void main(String[] args) {
        //XX预约婚庆公司（创建婚庆公司实例）:new Wedding()婚庆公司 ；new You()客户
        Wedding we = new Wedding(new You());
        we.HappyMarry();

//        new Thread(()-> System.out.println("我爱你")).start();
    }
}

//接口：结婚功能
interface Marry{
    public abstract void HappyMarry();
}

//角色：youself
class You implements Marry{
    @Override
    public void HappyMarry(){
        System.out.println("神父：新郎，你是否愿意这个女人成为你的妻子与她缔结婚约？无论疾病还是健康，无论贫穷还是富有，或任何其他理由，都爱她，照顾她，尊重她，接纳她，永远对她忠贞不渝直至生命尽头？");
        System.out.println("我：去你MD，劳资作为要征服全世界女人的后宫王，这辈子不可能结婚的");
    }
}

//婚庆公司：布置场景，婚前过程，收钱
class Wedding implements Marry{
    //使用Marry对象是因为：但凡实现了Marry接口的对象都可以使用该（婚庆公司）构造函数，通俗点就是一个接待统一接待所有客户
    //如果使用用户的对象，那么针对不同的对象就得创建不同的接待人员，这样会导致人力资源的浪费
    private Marry target;

    public Wedding(Marry target){
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    public void before(){
        System.out.println("结婚之前，布置场景");
    }

    public void after(){
        System.out.println("结婚之后，收钱");
    }
}

5.线程停止

5.1线程的四大状态

  1. **新生期：**创建Thread对象
  2. **就绪状态：**调用start()方法进入就绪状态，此时需等待cpu的调度 (注意，不能对已经启动的线程再次调用start方法，否则会抛出异常)
  3. **执行状态：**线程获得cpu的调度后，线程就进入Running（执行状态）并自动调用run()方法执行方法体，当运行中的线程调用yeild()方法，则该线程会让出cpu的控制权，进入Running状态。但该线程有可能再次降到cpu的控制权继续执行
  4. **死亡状态：**当线程的run()方法执行完之后，或者被强制终止(如调用方法：stop(),destory()),或发生Error、Exception等，那么这个线程就处于死亡状态这个线程对象也许是活的，但是它已经不是一个单独执行的线程。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

6.线程休眠sleep

sleep()方法：sleep是Thread的一个静态方法，主要作用是阻塞线程的运行，使线程进入一定的休眠时间，时间到达后，线程重新进入执行状态，

每一个对象都有一把锁，sleep不会释放锁

package com.hsf.JavaSE.Thread;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
* 模拟倒计时
* */
public class Sleep {
    public static void main(String[] args) throws InterruptedException {
        String time ;
        boolean flag = true;
        while(flag){
            time = new SimpleDateFormat("yyyy:MM:dd HH:mm:ss").format(new Date(System.currentTimeMillis()));
            System.out.println(time);
            Thread.sleep(1000);
        }
    }
}

7.线程礼让yield

**yield()方法：**yield()方法是Thread的一个静态方法，主要作用是让正在运行的线程重新进入到执行状态Running，礼让不一定成功，因为有可能我让了你下一次还是我先执行，主要还是看cpu的调度，这可能就是关系户吧

package com.hsf.JavaSE.Thread;

public class TestYield {

    public static void main(String[] args) {
        MyYield yield = new MyYield();
        new Thread(yield,"a").start();
        new Thread(yield,"b").start();

        //lamda表达式
        new Thread(()-> System.out.println("三玖天下第一")).start();
    }
}

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
       Thread.yield();//礼让,但不一定成功，看cpu的调度
        System.out.println(Thread.currentThread().getName()+"执行完毕");
    }
}

8.线程强制执行

**join()方法:**join()方法是Thread的一个静态方法，主要作用是强制占有cpu资源，使其他线程进入阻塞状态，可能，这就是vip用户吧

package com.hsf.JavaSE.Thread;

public class Testjoin implements Runnable {

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

        //代理
        Thread th = new Thread(new Testjoin());
        th.start();

        for (int i = 0; i < 500; i++) {
            if(i==200){
                th.join();//插队
            }

            System.out.println("我是主线程main"+i);
        }
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是线程vip，都给我让开" +i);
        }
    }
}

9.线程的状态

  1. NEW：初始状态，线程刚被构建，但是还没有调用start()方法
  2. RUNNABLE：运行状态，Java系统系统中将操作系统中的就绪和运行两种状态笼统地称为“运行中”；
  3. BLOCKED：阻塞状态，表示线程阻塞于锁
  4. WAITTING：等待状态，表示线程进入等待状态，进入该状态表示当前线程做出一些特定动作（通知或者中断）
  5. TIME_WAITTING：超时等待状态，该状态不同于等待状态，它可以在指定的时间后自行返回
  6. TERMINATED：中止状态，表示当前线程已经执行完毕

new Thread().getState():获取线程的当前状态

Thread.State:枚举类型，线程的状态

10.线程的优先级

线程的优先级是为了在多线程环境中便于系统对线程的调度，优先级越高先执行机会越大，并不是一定先执行。

线程的优先级可以理解为线程抢占CPU时间片的概率，并不能保证优先级高的线程一定会先执行。

不同的系统有不同的线程优先级的取值范围，同一个优先级在不同的系统里的值可能是不同的。

一个线程的优先级设置遵从以下原则：

线程创建时，子继承父的优先级。

线程创建后，可通过调用setPriority()方法改变优先级。

线程的优先级是1-10之间的正整数，线程优先级最高为10，最低为1，默认为5。

1- MIN_PRIORITY

10-MAX_PRIORITY

5-NORM_PRIORITY

package com.hsf.JavaSE.Thread;

/*
* 线程的优先级
* */
public class PriorityTest {
    public static void main(String[] args) {
        aa a = new aa();
        aa a1 = new aa();
        aa a2 = new aa();
        Thread th = new Thread(a,"我是支线线程");
        th.setPriority(10);
        th.start();

        System.out.println(Thread.currentThread().getName()+"-->优先级："+Thread.currentThread().getPriority());

        Thread th1 = new Thread(a1,"支线线程2");
        th1.setPriority(1);
        th1.start();

        th1 = new Thread(a2,"支线线程3");
        th1.setPriority(5);
        th1.start();
    }

}

class aa implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->优先级："+Thread.currentThread().getPriority());
    }
}

11.守护线程与用户线程

在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)

用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

这里有几点需要注意：

(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
(2) 在Daemon线程中产生的新线程也是Daemon的。
(3) 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。

自定义守护线程（daemon）

package com.hsf.JavaSE.Thread;

/*
* 守护线程，虚拟机不用等守护线程结束
* */
public class DaemonTest {
    //用户线程
    public static void main(String[] args) {

        God god = new God();
        Thread th = new Thread(god);
        th.setDaemon(true);//默认false，表示用户线程，true表示守护线程
        th.start();
        new Thread(new Youu()).start();
    }
}

//上帝
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("我是上帝我不死");
        }
    }
}

//你
class Youu implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println("生命倒计时->"+(100-i));
            if(i==100){
                System.out.println("AWSL");
            }
        }
    }
}

12.同步方法及同步块

13.死锁

13.1概念：

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


//死锁：多个线程拿着对方需要的资源，都在等对方释放资源，形成阻塞
public class DeadLock {
    public static void main(String[] args) {
        Makeup makeup1 = new Makeup(0,"灰姑凉");
        Makeup makeup2 = new Makeup(1,"时崎狂三");
        makeup1.start();
        makeup2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makeup extends Thread{
    //需要的资源只有一份，用static来保证
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String girlName;//化妆的女孩名字

    public Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run(){
        try {
            //开始化妆
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //化妆的方法
    private void makeup() throws InterruptedException {
        if(choice==0){
            //同步块：锁住口红，不让其他线程使用，等我使用完了，才释放锁，让别人可以使用
            synchronized(lipstick){//获得口红的锁
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                //1s之后想获得镜子
                synchronized(mirror){
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else{
            synchronized(mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized(lipstick){
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }
}

13.1 互斥锁

互斥锁的类型

  • 普通锁（PTHREAD_MUTEX_NORMAL）：互斥锁默认类型。当一个线程对一个普通锁加锁以后，其余请求该锁的线程将形成一个等待队列，并在该锁解锁后按照优先级获得它，这种锁类型保证了资源分配的公平性。一个线程如果对一个已经加锁的普通锁再次加锁，将引发死锁；对一个已经被其他线程加锁的普通锁解锁，或者对一个已经解锁的普通锁再次解锁，将导致不可预期的后果。

  • 检错锁（PTHREAD_MUTEX_ERRORCHECK）： 一个线程如果对一个已经加锁的检错锁再次加锁，则加锁操作返回EDEADLK；对一个已经被其他线程加锁的检错锁解锁或者对一个已经解锁的检错锁再次解锁，则解锁操作返回EPERM；

  • **嵌套锁（PTHREAD_MUTEX_RECURSIVE）：**该锁允许一个线程在释放锁之前多次对它加锁而不发生死锁；其他线程要获得这个锁，则当前锁的拥有者必须执行多次解锁操作；对一个已经被其他线程加锁的嵌套锁解锁，或者对一个已经解锁的嵌套锁再次解锁，则解锁操作返回EPERM

  • **默认锁（PTHREAD_MUTEX_ DEFAULT）：**一个线程如果对一个已经加锁的默认锁再次加锁，或者虽一个已经被其他线程加锁的默认锁解锁，或者对一个解锁的默认锁解锁，将导致不可预期的后果；这种锁实现的时候可能被映射成上述三种锁之一；

13.2死锁避免方法

死锁产生的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个线程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

我们只需要想办法打破其中的任意一个或多个条件就可以避免死锁的发生

14.Lock锁（可重入锁）

14.1 Lock概述

从jdk5.0开始，java提供了更强大的线程同步机制—通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源的进行访问的工具，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

14.2 synchronized与Lock的区别

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

15（扩展）线程安全问题思考：

15.1 什么是进程

：电脑中时会有很多单独运行的程序，每个程序有一个独立的进程，而进程之间是相互独立存在的。比如下图中的QQ、酷狗播放器、电脑管家等等。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iKIxdGVh-1606389313119)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201113091510739.png)]

15.2 串行和并行

：说起多线程，这里就引申出了两个概念-串行和并行，

  • **串行：**所谓串行，其实是相对单条线程去执行多个任务来说的，就拿下载文件来说，当我们下载多个文件时，在串行中他是按照一定的顺序去下载的，如哔哩哔哩，爱奇艺等视频软件缓存视频，你必须等待前一个视频下载完了，第二个视频才能开始下载，它们在时间上是不可重叠的[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0y8ybHIc-1606389313121)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201113092341966.png)]

  • 并行：借上面的例子，下载多个文件时，开启多条线程同时进行下载，这里是严格意义上的，在同一时刻发生，并且在时间上是重叠的，如哔哩哔哩，爱奇艺等视频软件，当你开通了会员之后，你就可以同时下载多个视频，由此可见，这些视频软件针对缓存这一块的线程做出了限制，只有开通了会员之后，多线程的功能才会开放

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w06rMkqw-1606389313122)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201113092646811.png)]

15.3 什么是多线程？

：了解了这串行和并行之后，我们再来说说什么是多线程。举个例子，我们打开腾讯管家，腾讯管家本身就是一个程序，也就是说它就是一个进程，它里面有很多的功能，我们可以看下图，能查杀病毒、清理垃圾、电脑加速等众多功能。按照单线程来说，无论你想要清理垃圾、还是要病毒查杀，那么你必须先做完其中的一件事，才能做下一件事，这里面是有一个执行顺序的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ybmL4OUj-1606389313124)(C:\Users\asus\AppData\Roaming\Typora\typora-user-images\image-20201113093425857.png)]

如果是多线程的话，我们其实在清理垃圾的时候，还可以进行查杀病毒、电脑加速等等其他的操作，这个是严格意义上的同一时刻发生的，没有执行上的先后顺序。了解完这些之后，我们就需要去了解一个使用多线程不都不知道的问题----->线程安全

15.4 什么是线程安全？

既然是线程安全问题，那么毫无疑问，所有的隐患都是在多个线程访问的情况下产生的，也就是我们要确保在多条线程访问的时候，我们的程序还能按照我们预期的行为去执行，我们看一下下面的代码。

中…(img-0y8ybHIc-1606389313121)]

  • 并行：借上面的例子，下载多个文件时，开启多条线程同时进行下载，这里是严格意义上的，在同一时刻发生，并且在时间上是重叠的，如哔哩哔哩，爱奇艺等视频软件，当你开通了会员之后，你就可以同时下载多个视频，由此可见，这些视频软件针对缓存这一块的线程做出了限制，只有开通了会员之后，多线程的功能才会开放

    [外链图片转存中…(img-w06rMkqw-1606389313122)]

15.3 什么是多线程？

：了解了这串行和并行之后，我们再来说说什么是多线程。举个例子，我们打开腾讯管家，腾讯管家本身就是一个程序，也就是说它就是一个进程，它里面有很多的功能，我们可以看下图，能查杀病毒、清理垃圾、电脑加速等众多功能。按照单线程来说，无论你想要清理垃圾、还是要病毒查杀，那么你必须先做完其中的一件事，才能做下一件事，这里面是有一个执行顺序的。

[外链图片转存中…(img-ybmL4OUj-1606389313124)]

如果是多线程的话，我们其实在清理垃圾的时候，还可以进行查杀病毒、电脑加速等等其他的操作，这个是严格意义上的同一时刻发生的，没有执行上的先后顺序。了解完这些之后，我们就需要去了解一个使用多线程不都不知道的问题----->线程安全

15.4 什么是线程安全？

既然是线程安全问题，那么毫无疑问，所有的隐患都是在多个线程访问的情况下产生的，也就是我们要确保在多条线程访问的时候，我们的程序还能按照我们预期的行为去执行，我们看一下下面的代码。

一只java小白白的奋斗史
关注
专栏目录
C++学习笔记--多线程
du_qi的博客
08-26 3121
优缺点对比： 多线程开销小，但难于管理，且不能用于分布式系统； 多进程开销大，操作系统会进行一部分管理，因此用户管理就比较简单，可用于分布式； 通常多线程和多进程结合使用。 参考资料：http://edu.csdn.net/course/detail/2303/35894?auto_start=1 [TOC] 代码实例：1 最简单的多线程#include <iostream> #incl
C++11并发与多线程笔记（9） async、future、packaged_task、promise
qq_38231713的博客
05-13 4275
第九节、async、future、packaged_task、promise 本节内容需要包含头文件#include 一、std::async、std::future创建后台任务并返回值 std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。 什么叫“启动一个异步任务”？就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回
Linux 4种互斥锁
仗剑天涯
07-17 4760
linux 互斥锁
C++多线程学习笔记
最新发布
yongzhouchen的博客
07-07 477
实际开发中不会直接使用互斥量，而是搭配模板lock_guard使用，或者搭配功能更多的模板unique_lock使用。信号量(semaphore)只在C++20之后的标准有(了解)使用mutex互斥量。
C++编程笔记(多线程学习)
刀刀的博客
01-17 668
C++11多线程编程学习，重点讲述有关线程传参问题
Java多线程笔记
weixin_44863459的博客
09-26 117
Java多线程 线程和进程 线程是指程序在运行过程中，一个执行程序代码的执行单元，一个线程指的是进程中的一个单一独立的控制流，一个进程可以同时并发运行多个线程，并且每一个线程并行执行不同的任务。 进程是指一个正在执行的程序，一个进程包括由操作系统分配的内存空间，包含一个或多个线程，且一个线程不能独立存在，它必须是进程的一部分，一个进程一直运行直到所有的非守护线程都结束后才能结束进程，而多线程则能够达到编写高效率程序来充分的利用CPU资源的目的。在Java语言中线程共有五种状态，分别为新建、就绪、运行、挂起、
java rtp打包_多媒体开发之rtp打包---打包中的FU-A分包方式说明
weixin_32822843的博客
02-16 409
继上篇rtp中的时间戳和负载类型之后，升入到了nalu的分片打包问题，这里做下笔记(1)fu-a的打包格式1.基于RTP协议的打包及解包(1)单个NAL打包H.264NALU单元常由[start code][NALU header][NALU payload]三部分组成，其中start code 用于标志一个NALU单元的开始，必须是“00000001”或者是“000001”，打包时去掉开始码，把...
fuse多线程
peter_cloud的专栏
04-19 1762
高级开发(high-level)   多线程模式        如果在多线程运行的情况下，如果处理请求的一个线程出现阻塞但整个系统中所有可用的线程数量超过10时，则系统就会自动关闭线程，如果可用线程为0,系统就会自动创建线程来处理请求，在系统中请求的线程不会由于请求的阻塞而导致线程阻塞后，无线程处理来自文件系统的请求。   在运行高级模式开发,通过命令行进行设置(默认
python课程笔记
weixin_42393960的博客
11-13 1308
python学习笔记一、python1.计算机组成2.了解python2.1特点2.2版本号2.3、python基础学习路线二、python入门2.1、环境搭建2.1.1、python解释器2.1.2、下载python解释器2.1.3、PyCharm2.1.4、注释2.2、变量2.3、输出2.4、输入2.5、数据类型三、流程控制3.1、条件语句3.2、循环四、数据序列4.1、字符串4.2、列表4.3、字典4.4、元组五、函数5.1、参数5.2、返回值六、文件操作七、面向对象八、模块、包、异常九、综合实战二、
笔记-多线程
julienetan的博客
04-26 280
一、多线程概念 a、什么是线程？ 线程是程序执行的一条路径，一个进程中可以包含多条线程 ；多线程并发执行可以提高效率，同时完成多项工作； b、应用场景？ 迅雷开启多条线程一起下载 二、多线程并行和并发的区别 并行就是两个任务同时运行，（需要多核CPU）；并发就是两个任务都请求运行，而处理器只能执行一个任务，就把这两个任务安排轮流执行，由于时间间隔较短，使人感觉两个任务都在运行。 三、
java笔试题算法-javase:javase的笔记
06-03
向下，生动清晰阐述JVM原理，内存管理，垃圾回收算法，系统调用，多线程及各种锁实现源码分析，BIO/NIO/AIO到Netty源码原理，全程项目贯穿，推动理论实践，上课等于上班，经验超过传统教学后工作一年经验，夯实的...
C语言的进制转换以及算法实现
热门推荐
黑虎阿福的博客
01-20 3万+
楔子 2021-1-20，天气阴，今天感觉乱糟糟的，心态也不好，什么都提不起兴趣来，唉，这疫情什么时候才能结束啊！！！ 1、其他进制转十进制 1.1、二进制转十进制 转换规程： 从最低位开始，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和，例如： 二进制 1011 = 1*2^0 + 1*2^1 + 0*2^2 + 1*2^3 = 1 + 2 + 0 + 8 = 11 1.2、八制转十进制 转换规则： 从最低位开始，将每个位上的数提取出来，乘以8的(位数-1)次方，然后求和，例如：
# Maven错误Error executing Maven.
黑虎阿福的博客
11-25 2万+
错误Error executing Maven. 今天第一次创建maven项目，遇到了Error executing Maven. Cannot resolve plugin org.apache.maven.plugins:maven-site-plugin:3.3 Cannot resolve plugin org.apache.maven.plugins:maven-site-plugin:3.3 Cannot resolve plugin org.apache.maven.plugins:maven
C语言的位运算详解
黑虎阿福的博客
01-21 7289
楔子 2021-1-21日，天气阴      我像往常一样起床、开始写代码，突然我感到一种莫名的心情在我心中翻涌，虽不强烈，但也让我有了点与代码无关的念头。 1、位运算 位运算说明： 按位与& ： 两个全为1，结果为1，否则为0 按位或| ：两个有一个为1，结果为1，否则为0 按位异或 ^：两个一个为0，一个为1，结果为1，否则为0 按位取反 ~： 0 -> 1，1->0 按位左移<<：将一个运算对象的各二进制位全部左移若干
C语言中三元运算符的嵌套细节说明
黑虎阿福的博客
01-18 5165
楔子 2021-1-18，天气晴         呼姆！今天又是个好天气，我久违的早起一次去外面吃早餐，因为疫情的原因，我最喜欢的那家兰州拉面至今仍是歇业状态，内心感到有点可惜，胡乱的在街上买了点吃的之后就回家了。（嗯，不错，又是流水账一样的的记录，但还是会坚持写的，感觉不写点什么，心里就空落落的，每天看着屏幕上不断跳动着的代码，就感觉好空虚，于是我总会幻想着，如果又一天，我写的代码变成了卡哇伊的女孩子出现在我面前，然后温柔的对
C语言常量-#define与const的区别
黑虎阿福的博客
01-17 3411
楔子 2021-1-17 天气晴，无聊的一天，开始写代码吧！ 常量定义的两种方式 使用#define预处理器：#define 变量名 变量值 使用关键字const：const 数据类型 变量名 变量值 #define与const定义常量的区别 const定义常量时，需要带数据类型，而define不用带 const是在编译、运行的时候起作用，而define是在编译的预处理阶段起作用 define只是简单的替换，没有类型检查。简单的字符串替换会导致边界效应， #include <stdio.h&
错误 try 不带有 catch, finally 或资源声明
黑虎阿福的博客
05-20 3193
错误: ‘try’ 不带有 ‘catch’, ‘finally’ 或资源声明 public static void main(String[] args) { int a = 1; int b = 0; try{ System.out.println(a/b); }Catch(ArithmeticException e){ System.out.println("出现异常"); } } } 最后又仔细看了一下报错提示，突然发现我的catch的关键字写错了
关于C#窗体里为控件设置焦点的问题-Activated事件
黑虎阿福的博客
09-23 2823
关于C#窗体里为控件设置焦点的问题-Activated事件 问题详情 今天在写一个项目窗体的时候，需要用到输入框获取值，一般这种情况我们需要在窗体被激活的时候为控件设置焦点，于是我就想当然的为该窗体设置了一个加载事件，然后在加载事件里为这个文本控件设置了一个焦点，代码如下： /// <summary> /// 加载事件：当窗体加载后为输入框设置焦点 /// </summary> /// <param name="sender"
C语言中声明和定义的区别
黑虎阿福的博客
01-29 1593
1、声明和定义的区别 如果是指变量的声明和定义： 从编译原理上来说，声明是仅仅告诉编译器，有个某类型的变量会被使用，但是编译器并不会为它分配任何内存。而定义就是分配了内存。我们来看下面一段代码 void Func() { int a; int b=1; a=0; } 对于第一行代码，编译器不会做任何事，它不会为它在栈中分配一点东西，直到第三句，a=0;时，编译器才会将其压入栈中。而对于int b=0;这一句，编译器就会生成一条指令，为它赋值。如果反汇编，看到的代码可能是这样的： push 1; p
第一天学习c语言，程序一闪而过等问题及基础知识记录
黑虎阿福的博客
01-02 1142
简介 C语言是一门代码跨平台的面向过程的语言，不具有对象 （其他的就不说了，什么历史，特性之类的现在听了马上就会忘）； 创建一个c程序项目 以下以vs2015为例子创建c语言程序 点击——>文件——>新建 ——>项目 ，显示如下 然后我们选择空项目或者win32控制台应用程序都行，这里我以空项目为例子： 创建好之后是这样的 创建一个.c程序 选中源文件，点击右键，添加，c++文件； 注意，这里默认的是c++的文件，而我们需要的是c的文件，所以我们需要将.cpp改成.c,创建好之
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值