线程_线程池

1.认识Executor接口  最顶层接口

package com.hpd.executor;

import java.util.concurrent.Executor;

public class T01_MyExecutor implements Executor {

    public static void main(String[] args) {
        new T01_MyExecutor().execute(()->System.out.println("helllo executor"));
    }

    @Override
    public void execute(Runnable command) {
        //new Thread(command).start();//开启一个线程去调用
        command.run();//直接的方法调用
    }

}

2.ExecutorService接口  (继承自Executor接口)

  除了继承的executor()方法外,还提供了submit(Callable<T> task)方法,submit(Runnable task)

3Executors工具类

4ThreadPool

  

package com.hpd.executor;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import javax.swing.plaf.synth.SynthSplitPaneUI;

public class T02_ThreadPool {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(5);
        for(int i=0;i<6;i++) {
            service.execute(()->{
                try {
                    TimeUnit.MICROSECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);

        service.shutdown();
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);

        TimeUnit.MICROSECONDS.sleep(5000);
        System.out.println(service.isTerminated());
        System.out.println(service.isShutdown());
        System.out.println(service);

    }

}

[email protected][Running, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
false
true
[email protected][Shutting down, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
pool-1-thread-2
pool-1-thread-4
pool-1-thread-1
pool-1-thread-5
pool-1-thread-3
pool-1-thread-2
true
true
[email protected][Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]

5FutureTask和Future

package com.hpd.executor;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class T03_Future {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Integer> task = new FutureTask<>(()-> {   //用FurureTask包装Callable任务
            TimeUnit.MILLISECONDS.sleep(500); //Thread只能传入FutureTask不能传入Callable
            return 1000;
        });
        new Thread(task).start();
        System.out.println(task.get());//阻塞

        ExecutorService service = Executors.newFixedThreadPool(5);
        Future<Integer> f= service.submit(()->{ //submit方法直接传入Callable任务
            TimeUnit.MICROSECONDS.sleep(500);
            return 1;
        });
        System.out.println(f.isDone());

    }

}

6.------

原文地址:https://www.cnblogs.com/huangpeideng/p/10260999.html

时间: 2024-10-31 11:28:16

线程_线程池的相关文章

Lock锁_线程_线程域

using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading;using System.Threading.Tasks;using System.Windows.Forms; namespace Lock锁_线程_线程

PoEdu - Windows阶段班 【Po学校】Lesson006_线程_线程的启动到消亡 &amp;线程状态 &amp; 线程安全 &amp; CONTEXT结构体 &amp; 令牌锁

011_线程启动到死亡的详细讲解 1. 线程内核对象 使用计数 2 ##决定当前线程何时销毁 暂停计数 1 ##UINT类型初始为1,可以暂停多次,如置为0则取消暂停. 退出代码 STILL_ACTIVE Signaled FALSE CONTEXT 为空 2. 栈##在隶属于当前进程的空间中,分配一块"栈"空间,以供线程使用 参数 lpParam 入口地址 lpfnAddr 3. CONTEXT##线程上一次运行时的寄存器 IP(指令寄存器) void RtlUserThreadSt

10_控制线程_线程让步yield

[线程让步yield()方法] yield()方法可以让当前正在执行的线程暂停,但它不会阻塞该线程,它只是将该线程从运行状态转入就绪状态. 只是让当前的线程暂停一下,让系统的线程调度器重新调度一次. 很有可能,当某个线程调用了yield()方法暂停之后进入就绪状态,它又马上抢占了CPU的执行权,继续执行. [注意] 实际上,当某个线程调用了yield()方法暂停之后,只有优先级与当前线程相同,或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会. [示例代码] package com.

09_控制线程_线程睡眠sleep

[线程睡眠] 如果需要让当前正在执行的线程暂停一段时间,并进入阻塞状态,则可以通过调用Thread类的静态方法sleep()方法来实现. sleep()方法有两种重载形式: 1.static void sleep( long millis ):让当前正在执行的线程暂停millis毫秒,并进入阻塞状态. 2.static void sleep( long millis,int nanos ):加上纳秒,很少使用该方法. 在当前线程调用sleep()方法进入阻塞状态后,在其睡眠时间段内,该线程不会获

java -&gt;多线程_线程池

线程池概念 线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源. 我们详细的解释一下为什么要使用线程池?(程序优化) 在java中,如果每个请求到达就创建一个新线程,开销是相当大的.在实际使用中,创建和销毁线程花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源要多的多.除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源.如果在一个jvm里创建太多的线程,可能会使系统由于过度消耗内存或"

多线程_创建线程_继承Thread类

public class ThreadDemo {   public static void main(String[] args){         Demo d = new Demo();   d.start();      for(int i = 0;i < 100;i++){      System.out.println("MainThread" + i);   }   } } class Demo extends Thread {   public void run(

InnoDB 存储引擎的线程与内存池

InnoDB 存储引擎的线程与内存池 InnoDB体系结构如下: 后台线程: 1.后台线程的主要作用是负责刷新内存池中的数据,保证缓冲池中的内存缓存的是最近的数据: 2.另外,将以修改的数据文件刷新到磁盘文件: 3.同时,保证在数据库发生异常的情况下,InnoDB能恢复到正常运行状态. 内存池:InnoDB有多个内存块,这些内存块组成了一个大的内存池.这些内存块包括有:缓冲池(innodb_buffer_pool)和日志缓冲(log_buffer)以及额外内存池(innodb_addtional

线程和线程池

首先线程有守护线程和用户线程两种,区别就是用户线程是否保持程序的运行状态.当程序在运行时,必定有一个或以上的线程是用户线程,而当程序结束时,所有守护线程也都将被关闭.使用Thread.setDaemon(ture)可以把线程标记为守护线程,默认线程状态继承自创建它的线程.线程的两种创建方法不多说了. 线程安全一般指的是共享变量被多个线程访问读写造成的数据不一致或者是数据不完整性.一般有如下几种方法可供参考: 1.synchronized方法,提供只能供一个线程访问的类,方法或语句块,控制变量的修

java 线程、线程池基本应用示例代码回顾

package org.rui.thread; /** * 定义任务 * * @author lenovo * */ public class LiftOff implements Runnable { protected int countDown=10; private static int taskCount=0; private final int id=taskCount++; public LiftOff(){} public LiftOff(int countDown) { thi