多线程、线程池以及Lambda表达式的总结笔记分享

最新推荐文章于 2022-06-08 21:56:13 发布
最新推荐文章于 2022-06-08 21:56:13 发布
阅读量649 收藏 2
点赞数 1
分类专栏： # Java SE 文章标签： 多线程 线程池 lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44010763/article/details/114929180
版权

文章目录

1. 多线程技术

1.1 线程与进程

  • 进程

    ​ 是指一个内存中运行的应用程序（现在很多软件都是多进程的了，比如百度云），是系统运行程序的基本单位，每个进程都有一个独立（进程之间的内存不共享）的内存空间 。

    ​ 系统运行一个程序即是一个进程从创建、运行到消亡的过程。

  • 线程

    ​ 是进程中的一个执行路径，线程是进程中的一个执行单元，共享一个内存空间（每个线程都有自己的栈空间，堆内存是共有的），线程之间可以自由切换，并发执行。一个进程最少有一个线程，一个进程如果没有线程在执行了的话就运行结束了，线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。

注意：

​ 很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

1.2 守护线程和用户线程

  • 守护线程

    • daemonThread.setDaemon(true)：设置daemonThread为守护线程。

    ​ 守护线程是一种特殊的线程，用于守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡。

  • 用户线程

    ​ 用户线程可以认为是系统的工作线程，它会完成这个程序要完成的指定任务，我们直接创建的线程都可以看作是用户线程。如果用户线程全部结束，那么整个应用程序就应该结束。因此，当一个Java应用内只有守护线程时，Java虚拟机自然退出。

1.3 线程的六种状态

​ Thread.State类里面的，这是一个枚举Enum类。

  • NEW（新建状态）

    至今尚未启动的线程处于这种状态。

  • RUNNABLE（运行状态）

    正在JVM中执行的线程处于这种状态。

  • BLOCKED（阻塞状态）

    受阻塞并等待某个监视器锁的线程处于这种状态。

  • WAITING（等待状态）

    无限期等待另一个线程来执行某一特定操作的线程处于这种状态。

  • TIMED WAITING（休眠状态）

    等另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

  • TERMINATED（死亡状态）

    已退出的线程处于这种状态。
    在这里插入图片描述

1.4 线程的调度

  • 分时调度

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

  • 抢占式调度

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为 抢占式调度。

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

1.5 同步与异步

  • 同步

    排队执行 , 效率低但是安全

  • 异步

    同时执行 , 效率高但是数据不安全.

1.6 并发与并行

  • 并发

    指两个或多个事件在同一个时间段内发生。

  • 并行

    指两个或多个事件在同一时刻发生（同时发生）。

1.7 Thread类

1.7.1 Thread类的常用构造方法

  • Thread()

    分配新的 Thread对象。

  • Thread(Runnable target)

    分配一个带有指定任务的、新的 Thread对象。

  • Thread(Runnable target, String name)

    分配一个具有指定名字的、带有指定任务的、新的 Thread对象。

  • Thread(String name)

    分配具有指定名字的、新的 Thread对象。

  • void setDaemon(boolean on)

    将此线程标记为 daemon线程或用户线程

1.7.2 Thread类的常用方法

  • String getName()

    返回此线程的名称。

  • void run()

    如果此线程是使用单独的Runnable运行对象构造的，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。

  • void start()

    导致此线程开始执行; Java虚拟机调用此线程的run方法。

  • static void sleep(long millis)

    导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数。

  • static Thread currentThread()

    返回对当前正在执行的线程对象的引用。

  • void join()

    等待该线程终止，待此线程执行完成后，再执行其他线程，其他线程阻塞（可以看作插队）

  • setPriority(int newPriority)

    更改线程的优先级

  • void interrupt()

    中断此线程,就是给这个线程打个标记，告诉它你应该死亡了。

  • static boolean interrupted()

    测试当前线程是否已被中断。

  • boolean isAlive()

    测试线程是否处于活动状态

1.8 线程的开启方法

​ main方法是运行在main线程里的，即主线程，后面开启的线程都是分支。

  1. 创建一个类A，让他继承Thread类
    1. 重写run方法;
    2. A a = new A();
    3. 调用start方法：a.start()。
  2. 创建一个类B，实现Runnable接口
    1. 实现抽象方法run();
    2. B b = new B();//创建一个任务对象
    3. new Thread(b);//创建一个线程，为其分配一个任务
    4. 然后调用start方法。

注意：

​ 通过实现Runnable接口的方式更好！！！

​ 通过创建任务、给线程分配任务的形式创建线程，更适合多个线程同时执行相同任务的情况，并且可以避免单继承的局限性，任务与线程分离可以提高程序的健壮性，后续学习的线程池技术只接受Runnable类型的任务，不接受Thread类型的线程。


1.9 线程安全

1.9.1 线程安全的原因、背景

​ 如果多个线程在同时运行，而这些线程可能会同时执行一样的代码，比如说售票问题，售票窗口在卖票，PC端也在卖票，移动端也在卖票，因此我们必须保证多线程的数据同步性。

​ 如果多线程不访问共享数据，是不会出现线程安全问题的。

1.9.2 线程安全的解决方法

​ 在使用多线程且访问共享数据的时候，必须保证数据的同步性，解决线程不安全的现象。为了保证每个线程都能正常执行原子操作，java引入了线程同步机制，有三种方式完成同步操作：

1.9.2.1 同步代码块（synchronized）
synchronized(同步锁对象){
	//需要保证线程安全的代码段
}
  • 对象的同步锁（也叫对象锁）只是一个概念，可以看作是在对象上标记了一个锁。
  • 锁对象可以是任意类型
  • 多个线程对象要使用同一把锁（谁有钥匙谁进入代码块，其他线程进入阻塞状态）。
1.9.2.2 同步方法
public synchronized void method(){
	//需要保证线程安全的代码段
}
  • 在这个方式中，对于非静态方法，同步锁就是this；对于静态方法来说，就是我们使用当前方法所在类的字节码对象（所在类.class）
  • 如果是静态的方法，那访问的共享数据，也必须是静态的。
1.9.2.3 显式锁：Lock锁

​ 同步代码块和同步方法都是属于隐式锁，Lock锁是接口，创建这样的显示锁的时候，通过其子类实现（ReentrantLock，比较常用）。

  1. 创建Lock锁

    Lock l = new ReentrantLock();

  2. 加锁

    l.lock();

  3. 解锁

    l.unLock();
1.9.2.4 显示锁和隐式锁的区别

​ 所谓的显式锁和隐式锁的区别，也就是Synchronized和Lock的区别。

  • （一）实现的层次不同

    • Synchronized
      • Java中的关键字，是由JVM来维护的。是JVM层面的锁。
      • 底层是通过monitorenter进行加锁（底层是通过monitor对象来完成的，其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中，JVM才会调用monitor对象的）；通过monitorexit来退出锁的。
    • Lock
      • 是JDK5以后才出现的具体的接口以及类。使用lock是调用对应的API。是API层面的锁。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
      • Lock是通过调用对应的API方法来获取锁和释放锁的。

  • （二）使用的方式不同

    • synchronized

      • 有代码块锁和方法锁，程序能够自动获取锁和释放锁。其是由系统维护的，除非逻辑问题，不然不会出现死锁。

      • 原始采用的是CPU悲观锁，即独占锁。当很多线程竞争锁的时候，会引起CPU频繁的上下文切换，效率低。

    • Lock

      • Lock只有代码块锁，需要手动的获取和释放锁，并且需要配合try/finally语句块来完成（保证资源释放，不被死锁）。如果没有释放锁，就有可能导致出现死锁的现象。死锁的四个必要条件（破坏其一）：

        • 互斥条件

          一个资源每次只能被一个进程使用；

        • 请求与保持条件

          一个进程因请求资源而阻塞时，对已获得的资源保持不放；

        • 不剥夺条件

          进程已获得的资源，在末使用完之前，不能强行剥夺；

        • 循环等待条件

          若干进程之间形成一种头尾相接的循环等待资源关系。

      • 采用得到是乐观锁的方式（Compare and Swap, CAS），每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。

  • （三）等待是否可以被中断

    • synchronized
      不可中断，除非抛出异常或者正常运行完成。

    • Lock
      可以中断的，中断方式：

      • 调用设置超时方法tryLock(long timeout ,timeUnit unit)

      • 调用lockInterruptibly()放到代码块中，然后调用interrupt()方法可以中断

  • （四）是否可以设置成公平锁

    • synchronized
      只能为非公平锁。

    • lock

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

      true：公平锁、false：非公平锁

  • （五）锁绑定多个条件condition

    • synchronized
      不能精确唤醒线程。要么随机唤醒一个线程；要么是唤醒所有等待的线程。

    • Lock
      用来实现分组唤醒需要唤醒的线程，可以精确的唤醒。

  • （六）性能区别

    • synchronized

      • 托管给JVM执行，Java1.5中，由于需要调用操作接口，可能导致加锁消耗时间过长，与Lock比性能低。

      • 1.6以后，语义定义更加清晰，有适应自旋、锁粗化、锁消除、轻量级锁、偏向锁等，可进行许多优化，性能提高了，与Lock差不多。

    • Lock
      java写的控制锁的代码，性能高。

1.10 公平锁和非公平锁

  • 公平锁：先到先得，得排队。

  • 非公平锁：大家一起抢，谁抢到算谁的。

1.10.1 公平锁的实现方式
Lock l = new ReentrantLock();//默认是非公平锁
Lock l = new ReentrantLock(true);//true：公平锁、false：非公平锁

1.11 线程通信（等待与唤醒机制）

1.11.1 线程通信的概念

​ 多线程并发执行的时候，默认情况下CPU随机切换线程，而可能存在多个线程处理同一个资源，但是处理的动作不同，这是就需要他们之间协调通信，完成对同一个资源的操作。

​ 线程通信问题，即生产者与消费者问题。

​ 例如，A是厨师，B是顾客，菜是要处理的统一资源，A做好了菜，就要唤醒B去吃，然后自己等待；B吃完就去唤醒A再去做，自己等待。

1.11.2 线程通信的方法

  1. wait()

    ​ 线程不再活动，进入wait set中，因此不会浪费资源，也不会去竞争锁，此时状态为WAITING。等待别的线程调用notify方法唤醒它，然后它才会重新进入调度队列。

  2. wait(long millis)

    ​ 进入Timed WAITING状态，在指定时间内不再活动，进入wait set中。

  3. notify()

    ​ 随机选取所通知对象的wait set中的一个线程释放。

  4. notifyAll()

    ​ 选取所通知对象的wait set中的全部线程释放。


1.12 Callable接口

​ 主流认知上，线程的开启（创建）有两种方式，但是实际上Callable也可以，Callalble接口支持返回执行结果。

  • 主线程如果需要获取Callalble线程的返回值，那就调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞；
  • 主线程如果想在指定时间内等待获取，那就调用FutureTask.get((long timeout, TimeUnit unit)得到；
  • 主线程如果想判断Callalble线程是否执行完毕，可以使用FutureTask.isDone()；
  • 主线程之前等待了，但是如果不想继续等待了，可以调用FutureTask.cannel()取消等待（干掉这个线程）。
//Callable接口
public interface Callable<V> {
	V call() throws Exception;
}
//Runnable接口
public interface Runnable {
	public abstract void run();
}
1.12.1 Callable使用步骤
//1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
    @Override
    public <T> call() throws Exception {
    	return T;
    }
}

//2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);//callable是上面的实例对象

//3. 通过Thread,启动线程
new Thread(future).start();//也是通过指定任务的方式创建线程


//
1.12.2 Runnable和Callable的相同点
  • 都是接口 ；
  • 都可以编写多线程程序 ；
  • 都采用Thread.start()启动线程。
1.12.3 Runnable和Callable的不同点
  • Runnable没有返回值；
  • Callable可以返回执行结果 Callable接口的call()允许抛出异常；Runnable的run()不能抛出。

2. 线程池

​ 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

​ 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

2.1 线程池的好处

  • 减少资源消耗；
  • 提高响应速度；
  • 提高线程的可管理性。

2.2 线程池的分类

​ 线程池可以分为四类：缓存线程池、定长线程池、单线程线程池、周期性任务定长线程池。

​ 线程池中分为线程数组和任务列表，任务进来分配给线程数组中的线程执行。

没有引用指向且没有剩余线程的线程池将会自动关闭

2.2.1 缓存线程池

​ 长度无限制，执行时会判断线程池是否有空闲线程，如果有就使用，没有就创建一个线程，并放入线程池中，然后使用。

//缓存线程池示例

//第一步：创建缓存线程池
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());
	}
});
2.2.2 定长线程池

​ 长度是指定的数值，执行时会判断线程池是否有空闲线程，有三种情况：

  • 如果有就使用；
  • 如果没有，而且线程池没有满，就创建一个线程，并放入线程池中，然后使用；
  • 如果没有，而且线程池满了，则等待线程池存在空闲线程。
//定长线程池示例
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());
    }
});
2.2.3 单线程线程池

​ 效果与定长线程池 创建时传入数值1效果一致，执行时会判断线程池是否有空闲线程，如果有就使用，没有就等待池中的单个线程空闲后使用。

//单线程线程池示例
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());
    }
});
2.2.4 周期性任务定长线程池

​ 即周期任务 + 定长线程池，周期性任务执行时会定时执行, 当某个时机触发时, 自动执行某任务。

​ 执行时判断线程池是否存在空闲线程 ：

  • 存在则使用；

  • 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用；

  • 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

    //周期性任务定长线程线程池示例
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行一次
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位(通过TimeUnit枚举类的常量指定)
*/
/*
service.schedule(new Runnable() {
    @Override
    public void run() {
    	System.out.println("俩人相视一笑~ 嘿嘿嘿");
    }
},5,TimeUnit.SECONDS);
*/

/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长，第一次执行是在什么时间之后)
* 参数3. 周期时长(每次执行的间隔时间，每隔多久执行一次)
* 参数4. 时长数字的单位(通过TimeUnit枚举类的常量指定)
*/
service.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
    	System.out.println("俩人相视一笑~ 嘿嘿嘿");
    }
},5,2,TimeUnit.SECONDS);

2.3 线程池创建问题

    在上述线程池使用时，我们使用了java.util.concurrent.Executors去创建线程池，但是在阿里巴巴开发手册中这是有问题的、不规范的。在实际应用时，我们应该使用ThreadPoolExecutor的方式创建，这样的处理方式可以更明确线程池的运行规则，规避资源耗尽的风险。而实际上，Executors内部封装调用了ThreadPoolExecutor去创建的。相信聪明的你可能已经发现了端倪，这里要说的问题就出在参数设置上。
    Executors返回的线程池对象的弊端主要有：

  1. FixedThreadPool和SingleThreadPool允许的请求队列长度为Integer.MAX_VALUE，可能会导致堆积大量的请求，从而OOM；
  2. CachedThreadPool允许的创建线程数量为Integer.MAX_VALUE,这可能会创建大量的线程，从而导致OOM。

3. Lambda表达式

3.1 函数式编程

  • 面向对象编程（OOP）

    ​ 做一件事情，找一个能解决这个事情的对象new，然后调用这个对象的方法，完成事情。

  • 函数式编程思想

    ​ 只要能获取到结果，谁去做，怎么做都不重要，重视结果，不重视过程。

3.2 Lambda表达式的使用条件

  1. 使用lambda表达式必须具有接口，无论是JDK内置的Runnable、Comparator接口还是自定义接口，都要求接口中有且仅有一个抽象方法；
  2. 使用Lambda表达式必须具有上下文推断，即方法或局部变量的类型必须为Lambda对应的接口类型。

3.3 Lambda表达式的标准格式

​ Lambda表达式由3部分组成：

  1. 一些参数
  2. 一个箭头
  3. 一段代码
(参数类型 参数名称) -> {代码语句}

3.4 Lambda表达式的省略格式

  1. 小括号内参数的类型可以省略；
  2. 如果小括号内有且仅有一个参数，则小括号可以省略；
  3. 如果大括号内（方法体内）有且仅有一条语句，则无论是否有返回值，可以同时省略大括号、return关键字以及语句分号。
Java战5渣
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线程池与Lambda表达式
m0_58702068的博客
11-23 398
线程池与Lambda表达式四种线程池缓存线程池：定长线程池3. 单线程线程池4. 周期性任务定长线程池Lambda表达式 一个线程执行任务的完整流程是： 创建线程 创建任务 执行任务 关闭线程 这个流程中创建线程和关闭线程耗费的时间在90%，而我们有时候创建线程就是为了执行一个很小的任务，这就会导致效率很低。 而线程池就是一个容纳多个线程的容器，池中的线程可以反复的使用，省去了频繁创建和销毁线程的时间。 线程池分为定长和非定常线程池，线程池的结构可以看作是数组形式，每个下标放一个线程。 四种线程池 Ja
Java之线程池与Lambda表达式
m0_43435611的博客
09-26 600
文章目录一、线程池1.1 缓存线程池CachedThreadPool1.2 定长线程池FixedThreadPool1.3 单线程线程池SingleThreadExecutor1.4 周期性任务定长线程池ScheduledThreadPool 一、线程池 提到线程线程池我们先来说一下线程池的好处，线程池的有点大概可以概括三点： 重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销。 能有效控制线程池的最大并发数，避免大量线程之间因互相抢夺系统资源而导致的阻塞现象。 能够对线程进行简单的管理，..
Java线程池初步学习
Yan__Ran的博客
06-08 265
目录一、什么是线程池二、为什么要有线程池？还有什么池？三、多线程学习：ExecutorServise接口1、线程池的关闭2、FixedThreadPool执行逻辑 3、CachedThreadPool执行逻辑四、ScheduledThreadPool线程池：周期性和定时性1、定时性:schedule方法2、周期性：scheduleAtFixedRate方法虽然启动一个新线程很方便，但是创建线程需要操作系统资源，比如说线程资源或者栈的空间。频繁地创建和销毁大量的线程会消耗大量时间。所以我们可以把很多小任务让一
Java线程池与Lambda表达式
Piink的博客
04-24 425
有没有一种方法使得线程可以复用(反复使用)，就是执行完一个任务，并不被销毁，而是可以继续执行其它的任务？ 在Java中可以通过线程池来达到这样的效果 线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源 线程池：容器–>集合（ArrayList、Hashset、Linkedlist hashmap） Java.util.concurrent.Executors:线程池的工厂类，用来生成线程池 Executors类中的静态方法：
线程池和Lambda表达式
baidu_39306983的博客
02-04 87
背景 当要执行新的线程任务时,我们就去创造一个线程,这样使用起来很方便 但存在的问题是,当频繁创建了很多线程,每个线程执行完就销毁了,开销很大，因为创建和销毁线程需要时间 使用一种方法线程池，使线程得以复用：线程执行完任务后，不销毁，可以继续执行下一个任务。 线程池 线程池中存放多个新建的线程，需要执行线程任务时，就往线程池中添加线程任务。 如果加入的线程任务数目超过线程池并发的线程数时，剩余的线程任务会先进入等待队列，直到线程池有线程空闲，再来执行这些剩余的任务。 使用 使用线程.
JAVA多线程（二）Lambda表达式 线程的五大状态和状态观测 优先级和守护线程
wjr0258的博客
06-08 354
Lambda表达式（函数式编程） 函数式接口：只含有唯一一个抽象方法的接口就是函数式接口。 对于函数式接口，可通过lamda表达式来创建该接口的对象。 /* 推导Lamda表达式 */ public class TestLambda1 { //3.静态内部类 static class Like2 implements ILike{ @Override public void lambda() { System.out.printl
线程池的概述和Lambda表达式
weixin_51492999的博客
10-16 228
文章目录线程池的概述线程池的使用Lambda表达式函数式编程思想概述冗余的Runnable代码Lambda标准格式Lambda省略格式&Lambda使用前提Lambda表达式的无参数无返回值的练习Lambda表达式有参数有返回值的练习Lambda表达式有参数有返回值的练习 线程池的概述 线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 合理利用线程池能够带来三个好处： 降低资源消耗。减少了创建和销毁线程的次数，每个工作线
day18【线程池、Lambda表达式】-笔记1
08-04
总的来说，线程池和Lambda表达式是Java编程中的高级特性，理解并熟练应用它们，可以提升代码质量和效率，使得多线程编程更加高效和易维护。通过学习等待唤醒机制，可以更好地控制并发环境下的线程行为，而Lambda...
java学习笔记总结
04-02
此外，Java的并发编程也是一大亮点，线程和同步机制（如synchronized关键字、volatile变量、Lock接口）使多线程环境下程序的执行变得更加可控。 最后，Java还包含了一些高级特性，如反射、注解和模块系统。反射允许...
C# 多线程笔记和示例讲解
09-12
以下是对"C#多线程笔记"中可能包含的知识点的详细解释。 1. **线程基础**： - **什么是线程**：线程是程序执行的最小单元，每个进程至少有一个线程，负责执行程序代码。 - **主线程与子线程**：主线程是程序的...
JavaSE精华笔记.zip
01-06
多线程是Java的一大特色，允许程序同时执行多个任务。这部分笔记会讲解线程的创建、同步、通信、生命周期管理等，帮助开发者理解和实现并发编程。 7. **7.网络编程.pdf**： Java提供了丰富的网络编程API，如...
java基础笔记，多线程、反射、java8
11-16
本文将深入探讨Java中的三个核心概念：多线程、反射以及Java 8的新特性，这些都是Java开发者必须掌握的重要知识点。 **多线程** 多线程是Java的一大亮点，它允许程序同时执行多个任务，提高系统资源的利用率和程序...
【线程状态、等待与唤醒、Lambda表达式、Stream流】
Requests
04-22 217
day09【线程状态、等待与唤醒、Lambda表达式、Stream流】 今日内容 多线程 线程的状态------>必须掌握 等待唤醒机制------>必须掌握 Lambda表达式 Lambda表达式的使用场景------>建议掌握 Lambda表达式的格式(标准\省略)------>建议掌握 Stream流 流式思想的概述 使用Stream流------>建议掌握 获取流–>操作流–>收集结果 第一章 线程状态 1.1 线程状态 线程状态
【多线程基础】线程状态 同步 协作 线程池 Lambda表达式
土味儿
07-27 225
目录一、基本概念二、线程创建1、继承 Thread 类1.1、实现步骤1.2、start 和 run 方法的区别?1.3、多线程下载图片案例2、实现 Runnable 接口 (推荐)2.1、实现步骤2.2、龟兔赛跑3、实现 Callable 接口 (了解)3.1、步骤3.2、改造多线程下载图片案例三、Lambda表达式 (箭头函数)1、介绍2、函数式接口3、示例3.1、定义接口3.2、传统实现类...
行为参数化的开发模式在日常工作中的使用-Lambda表达式和函数式接口
Lcy's Blog
01-31 345
目录 背景 介绍 具体示例 具体实现 优点 Lambda表达式和函数式接口 Lambda 函数式接口 使用函数式接口 行为参数化对常用设计模式的重构 策略模式 普通策略模式 下面使用lambda表达式来重构 另外 模版方法 普通模版方法 下面使用lambda表达式来重构这个模版方法 另外 工厂模式 普通工厂模式 下面使用lambda表达式来重构这个模版方法 另外 结语 背景 在日常开发中，有个众所周知的问题，不管你做什么，用户的需求肯定会变。 比方说...
java线程池底层运行过程以及参数详解
叶新东老师的博客
04-24 773
相信线程池这个东东只要只要是做过开发的童鞋们都熟悉，用起来那是相当地简单啊，而且功能强劲，优化的又好，使用还去除了冗余的代码层级，提高了代码的可读性，创建线程池只需要用到四种 newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定...
java学习笔记6——线程池及Lambda表达式
weixin_44388890的博客
11-12 203
线程池的概念和原理： 线程池：容器–>集合（ArrayList，HashSet，LinkedList，HashMap） 当程序第一次启动的时候，创建多个线程，保存到一个集合中 当我们想要使用线程的时候，就可以从集合中取出来线程使用 Thread t = list.remove(0):返回的是被移除的元素，（线程只能被一个任务使用） Thread t = linked.removeFist()...
系统介绍|围填海项目遥感监视监测系统介绍3——填海范围提取
海洋GISer成长记
09-29 1724
填海范围提取可以理解为对水体范围的提取，然后再根据水体范围提取填海范围。基于遥感影像的水体范围提取有多种方法，主要包括单波段阈值法、多波段谱间关系法、归一化差异水体指数法（NDWI）和面向对象提取方法等。 ENVI软件提供面向对象的空间特征提取模块（Feature Extraction），该模块包含3个工具，分别是基于样本的特征提取（Example based Feature Extraction Workflow）、基于规则的特征提取（Rule Based Feature Extraction Work
分布式电网动态电压恢复器模拟装置设计与实现.doc
最新发布
07-06
本装置采用DC-AC及AC-DC-AC双重结构，前级采用功率因数校正（PFC）电路完成AC-DC变换，改善输入端电网电能质量。后级采用单相全桥逆变加变压器输出的拓扑结构，输出功率50W。整个系统以TI公司的浮点数字信号控制器TMS320F28335为控制电路核心，采用规则采样法和DSP片内ePWM模块功能实现SPWM波，采用DSP片内12位A/D对各模拟信号进行采集检测，简化了系统设计和成本。本装置具有良好的数字显示功能，采用CPLD自行设计驱动的4.3英寸彩色液晶TFT-LCD非常直观地完成了输出信号波形、频谱特性的在线实时显示，以及输入电压、电流、功率，输出电压、电流、功率，效率，频率，相位差，失真度参数的正确显示。本装置具有开机自检、输入电压欠压及输出过流保护，在过流、欠压故障排除后能自动恢复。
多线程怎么使用lambda表达式
06-01
在Qt中，可以使用lambda表达式来实现多线程。以下是一个简单的使用lambda表达式的示例： 1. 创建一个QThread对象，并将lambda表达式作为其构造函数的参数： ``` QThread* thread = new QThread([=]() { // 线程执行的代码 }); ``` 2. 调用start()函数启动线程： ``` thread->start(); ``` 3. 在lambda表达式中编写需要在该线程中执行的代码。注意，lambda表达式会在新线程中运行，而不是主线程中。 这只是一个简单的多线程示例。在实际应用程序中，需要更多的线程管理和同步技术来确保多个线程能够正确地协同工作，并避免出现竞态条件等问题。在Qt中，还有其他一些类和工具可用于实现更高级的多线程应用程序，如QThreadPool、QMutex、QWaitCondition等。 需要注意的是，在使用lambda表达式实现多线程时，需要特别注意线程安全性和避免出现竞态条件等问题。建议使用适当的线程同步和锁定机制来确保多线程安全。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值