【Java基础】多线程

最新推荐文章于 2022-10-04 23:08:00 发布
最新推荐文章于 2022-10-04 23:08:00 发布
阅读量110 收藏
点赞数
分类专栏： Java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41338341/article/details/115452533
版权

1. 概念

1.1 程序 vs 进程 vs 线程

术语概念
程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 。
进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位。
线程通常在一个进程中可以包含若干个线程，一个进程至少有一个线程。线程是CPU调度和执行的单位。

1.2 并发 VS 并行

术语概念
并发指两个或者两个以上事件在同一时间间隔内发生，即交替做不同事的能力，多线程是并发的一种形式。
并行指两个或者两个以上事件在同一时刻发生，即同时做不同事的能力。

2. 线程实现（重点）

线程的创建方式如下：

  • 继承Thread类
  • 实现Runnable接口
  • 实现Callable接口

2.1 Thread类

步骤：

  1. 自定义线程类继承Thread类
  2. 重写 run() 方法，编写线程执行体
  3. 创建线程对象，调用 start() 方法启动线程
// 创建线程方式 1 : 继承Thread类，重写run方法，调用start方法开启线程
//总结: 注意，线程开启不一定立即执行，由CPU调度执行

//第一步：继承Thread类
public class Thread1 extends Thread{

	//第二步：重写run方法
    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("这里是run方法-----" + i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
		
		//第三步：调用start方法开启线程
        Thread1 thread1 = new Thread1();  //创建一个线程对象
        thread1.start();    //调用start方法开启线程
        
        for (int i = 0; i < 20; i++) {
            System.out.println("这里是main方法-----" + i);
        }
    }
}

执行结果：

这里是main方法-----0
这里是main方法-----1
这里是main方法-----2
这里是main方法-----3
这里是main方法-----4
这里是main方法-----5
这里是main方法-----6
这里是main方法-----7
这里是main方法-----8
这里是main方法-----9
这里是main方法-----10
这里是main方法-----11
这里是main方法-----12
这里是main方法-----13
这里是main方法-----14
这里是main方法-----15
这里是main方法-----16
这里是main方法-----17
这里是main方法-----18
这里是main方法-----19
这里是run方法-----0
这里是run方法-----1
这里是run方法-----2
这里是run方法-----3
这里是run方法-----4
这里是run方法-----5
这里是run方法-----6
这里是run方法-----7
这里是run方法-----8
这里是run方法-----9

2.1 Runnable接口

步骤：

  1. 自定义线程类实现 Runnable接口
  2. 实现 run() 方法，编写线程执行体
  3. 创建该实现类的实例，并将此实例作为创建Thread对象时传入的参数
  4. 调用该Thead实例对象的 start() 方法启动线程
//创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start方法

//1. 实现Runnable接口
public class Thread2 implements Runnable{

    //2. 重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("这里是run方法-----" + i);
        }
    }

    public static void main(String[] args) {
        //3. 创建 Runnable 接口的实现类对象
        Thread2 thread2 = new Thread2();

        //4. 创建线程对象，通过线程对象来开启我们的线程，代理模式
        Thread thread = new Thread(thread2);
        thread.start();  //调用start方法开启线程

        //上面两句可以简写为
        //new Thread(thread2).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("这里是main方法-----" + i);
        }
    }
}

执行结果：

这里是main方法-----0
这里是run方法-----0
这里是run方法-----1
这里是main方法-----1
这里是run方法-----2
这里是main方法-----2
这里是run方法-----3
这里是run方法-----4
这里是run方法-----5
这里是run方法-----6
这里是run方法-----7
这里是main方法-----3
这里是run方法-----8
这里是main方法-----4
这里是main方法-----5
这里是main方法-----6
这里是main方法-----7
这里是main方法-----8
这里是main方法-----9
这里是main方法-----10
这里是main方法-----11
这里是main方法-----12
这里是main方法-----13
这里是main方法-----14
这里是main方法-----15
这里是main方法-----16
这里是main方法-----17
这里是main方法-----18
这里是main方法-----19
这里是run方法-----9

对比

方式特点
继承Thread类1. 子类继承Thread类具备多线程能力
2. 启动线程：子类对象.start()
3. 不建议使用：避免OOP单继承的局限性
实现Runnable接口1. 实现接口Runnable具有多线程能力
2, 启动线程：new Thread(Runnable接口实现类对象).start()
3. 推荐使用：可以避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

2.3 Callable接口

方式一（线程池）

步骤：

  1. 实现 Callable 接口，需要返回值类型
  2. 重写 call() 方法，需要抛出异常
  3. 创建实现类的实例
  4. 创建线程池服务：ExecutorService ser = Executors.newFixedThreadPool(线程个数);
  5. 提交执行：Future<返回值类型> result1 = ser.submit(实现类对象);
  6. 获取结果：返回值类型 r1 = result1.get();
  7. 关闭服务：ser.shutdownNow();
import java.util.concurrent.*;

/**
 线程创建方式3：实现Callable接口
 
 好处：
 1. 可以定义返回值
 2. 可以抛出异常
 
 */

public class Thread3 implements Callable<String> {

    @Override
    public String call() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread.sleep(100);//休眠
            System.out.println(Thread.currentThread().getName() + "----->" + i);
        }
        return Thread.currentThread().getName() + "执行完毕";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread3 t1 = new Thread3();
        Thread3 t2 = new Thread3();
        Thread3 t3 = new Thread3();

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<String> result1 = ser.submit(t1);
        Future<String> result2 = ser.submit(t2);
        Future<String> result3 = ser.submit(t3);

        //获取结果
        String r1 = result1.get();
        String r2 = result2.get();
        String r3 = result3.get();

        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);

        //关闭服务
        ser.shutdownNow();
    }
}

执行结果：

pool-1-thread-1----->0
pool-1-thread-2----->0
pool-1-thread-3----->0
pool-1-thread-3----->1
pool-1-thread-1----->1
pool-1-thread-2----->1
pool-1-thread-1----->2
pool-1-thread-2----->2
pool-1-thread-3----->2
pool-1-thread-1----->3
pool-1-thread-2----->3
pool-1-thread-3----->3
pool-1-thread-1----->4
pool-1-thread-2----->4
pool-1-thread-3----->4
pool-1-thread-1----->5
pool-1-thread-2----->5
pool-1-thread-3----->5
pool-1-thread-2----->6
pool-1-thread-1----->6
pool-1-thread-3----->6
pool-1-thread-2----->7
pool-1-thread-1----->7
pool-1-thread-3----->7
pool-1-thread-1----->8
pool-1-thread-2----->8
pool-1-thread-3----->8
pool-1-thread-2----->9
pool-1-thread-1----->9
pool-1-thread-3----->9
pool-1-thread-1执行完毕
pool-1-thread-2执行完毕
pool-1-thread-3执行完毕

方式二（FutureTask）

跟方式一差别不大，只是启动线程的方式不一样。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Thread4 implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("外面的风好凉快");
        return "我好想出去玩";
    }

    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new Thread4());
        new Thread(futureTask).start();

        try {
            String str = futureTask.get();
            System.out.println(str);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

执行结果：

外面的风好凉快
我好想出去玩

3. 线程状态

在这里插入图片描述

  • 创建状态： Thread t = new Thread()，线程对象一旦创建就进入到了新生状态。
  • 就绪状态： 当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行。
  • 运行状态： 进入运行状态，线程才真正执行线程体的代码块。
  • 阻塞状态： 当调用sleep，wait或者同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行。
  • 死亡状态： 线程中断或者结束，一旦进入死亡状态，就不能再次启动。也就是说，线程只能启动一次！

线程对象.getState()可以得到线程当前的状态。

boolean isAlive() 测试线程是否处于活动状态。

3.1 停止线程

  • 不要使用JDK提供的 stop() 或者 destroy() 等过时的或者JDK不建议使用的方法。
  • 建议自己编写一个公开的方法来让线程正常停止，可以设置一个标志位来控制循环次数，不建议死循环。
public class TestStop implements Runnable{

    //1. 设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread--->" + i++);
        }
    }

    //2. 设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main----->" + i);
            if(i == 90){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("该线程停止了");
            }
        }

    }
}

3.2 线程休眠 — sleep

  • static void sleep(long millis) 指定当前线程阻塞的毫秒数，1000ms=1s；
  • sleep抛出异常 InterruptedException；
  • sleep时间达到后，线程进入就绪状态；
  • sleep可以模拟网络延时，倒计时等等。
  • 每一个对象都有一个锁，sleep不会释放锁。
package test;

//模拟10秒钟倒计时
public class TestSleep {

    public static void main(String[] args) {
        try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while(true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if(num <= 0) break;
        }
    }
}

执行结果：

10
9
8
7
6
5
4
3
2
1

3.3 线程礼让 — yield

  • static void yield() 让当前正在执行的线程暂停，但不阻塞，让线程从运行状态转为就绪状态。
  • 让CPU重新调度，礼让不一定成功，看CPU心情。

比如现在有A、B两个线程，A线程处于运行状态，正在占用CPU资源，B处于就绪状态。然后A选择了礼让，这时候A和B都处于就绪状态，CPU重新调度，这时候有可能选择调度B，也有可能继续调度A，也就是说A不一定能够礼让成功。

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"线程1").start();
        new Thread(myYield,"线程2").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

礼让成功的情况：

线程1线程开始执行
线程2线程开始执行
线程2线程停止执行
线程1线程停止执行

礼让失败的情况：

线程2线程开始执行
线程2线程停止执行
线程1线程开始执行
线程1线程停止执行

3.4 线程插队 — Join

  • void join() 合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。
  • 可以想象成插队。
public class TestJoin implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 50; i++) {
            if(i == 25)  thread.join(); //插队
            System.out.println("main......" + i);
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("join......" + i);
        }
    }
}

执行结果：

main......0
main......1
main......2
main......3
main......4
main......5
main......6
main......7
main......8
main......9
main......10
main......11
main......12
main......13
main......14
main......15
main......16
main......17
main......18
main......19
main......20
main......21
main......22
main......23
main......24
join......0
join......1
join......2
join......3
join......4
join......5
join......6
join......7
join......8
join......9
main......25
main......26
main......27
main......28
main......29
main......30
main......31
main......32
main......33
main......34
main......35
main......36
main......37
main......38
main......39
main......40
main......41
main......42
main......43
main......44
main......45
main......46
main......47
main......48
main......49

3.5 线程优先级

  • Java提供一个线程调度器来监控程序中，启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
  • 线程的优先级用数字表示，范围从1~10
    • Thread.MAX_PRIORITY = 10;
    • Thread.MIN_PRIORITY = 1;
    • Thread.NORM_PRIORITY = 5;
  • 使用以下方式改变或者获取优先级
    • getPriority();
    • setPriority(int newPriority);
  • 优先级的设定要在启动 start() 调度之前。
  • main线程默认优先级为5。
  • 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这些都得看CPU的调度算法。

3.6 守护（daemon）线程

  • 线程分为用户线程和守护线程。
  • 虚拟机必须确保用户线程执行完毕。
  • 虚拟机不必等待守护线程执行完毕。
  • 典型的守护线程有GC线程。
  • 线程对象.setDaemon(true)设置守护线程。Daemon属性需要在启动线程之前设置，不能再启动后设置。
  • 守护线程可用来后台记录操作日志、监控内存、垃圾回收等待…
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        XiaoHua xiaoHua = new XiaoHua();

        Thread threadGod = new Thread(god);
        threadGod.setDaemon(true); //默认false表示这是用户线程，true表示这是守护线程
        threadGod.start(); // 启动守护线程

        new Thread(xiaoHua).start();//启动用户线程
    }
}

//1. 上帝 --- 守护线程
class God implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("上帝保佑着你！");
        }
    }
}

//2. 小华 --- 用户线程
class XiaoHua implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("小华活着的第" + i +"年");
        }
        System.out.println("=== goodbye world! ===");
    }
}

运行上面代码，可以发现，当用户线程执行结束时，守护线程并不会永无止境地执行下去，而是随着虚拟机的关闭而停止执行。

4. 线程同步（重点）

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题。为了保证数据在方法中被访问时的正确性，在访问同时加入 锁机制 synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。

使用锁机制，存在以下问题：

  • 一个线程持有锁会导致其他所有需要此锁的线程被挂起。
  • 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

4.1 同步方法以及同步块

线程不安全例子

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

执行结果：

8798

我们创建一个 list 来存放每个线程的名字，运行代码可以发现，实际存放在 list 里的线程名字个数并没有10000个。这是由于多个线程同一时间往同一位置插入名字，导致覆盖，所以才不满10000。

由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们需要针对方法提出一套机制，这一套机制就是 synchronized 关键字，它包括两种用法：synchronized方法 和 synchronized块。

  • 同步方法：public synchronized void method(int args){}
    • synchronized方法控制对 “对象” 的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
    • 缺陷：若将一个比较大的方法申明为 synchronized 将会影响效率。
  • 同步块：synchronized(Obj) {}
    • Obj 称之为同步监视器
      • Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器。
      • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class。
    • 同步块执行完毕之后就会释放锁。
    • 同步监视器的执行过程
    1. 第一个线程访问，锁定同步监视器，执行其中代码
    2. 第二个线程访问，发现同步监视器被锁定，无法访问
    3. 第一个线程访问完毕，解锁同步监视器
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

synchronized锁的是啥？

  • 普通同步方法 -----> 当前实例对象
  • 静态同步方法 -----> 当前类的Class对象
  • 同步方法块 -----> synchronized括号里配置的对象

使用同步块的例子

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        //因为主线程只是启动了10000个线程，有可能这1000个线程还没执行完，mian线程就执行输出list,size()，所以这里main线程需要睡眠一会，等待副线程全部执行完
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

运行结果：

10000

4.2 死锁

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

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

只要破坏上述的一个或多个条件就可以避免死锁的发生。
在这里插入图片描述

4.3 Lock锁

  • 从JDK5.0开始，Java提供了更强大的线程同步机制 —— 通过显式定义同步锁对象来实现同步，使用Lock对象充当同步锁。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类（可重入锁）实现了Lock接口，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

线程不安全例子

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

    int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums > 0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿到了票" + ticketNums--);
            }else{
                break;
            }
        }
    }
}

运行结果：

Thread-1拿到了票10
Thread-0拿到了票10
Thread-1拿到了票9
Thread-0拿到了票9
Thread-1拿到了票8
Thread-0拿到了票7
Thread-1拿到了票6
Thread-0拿到了票5
Thread-0拿到了票4
Thread-1拿到了票4
Thread-0拿到了票3
Thread-1拿到了票2
Thread-1拿到了票1
Thread-0拿到了票0

使用Lock锁之后的例子

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}

class TestLock2 implements Runnable{

    int ticketNums = 10;

    //1. 定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
        	//2. 加锁
            lock.lock();
            //3. 需要加锁的业务代码写在 try 块中
            try {                         
                if(ticketNums > 0){

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "拿到了票" + ticketNums--);
                }else{
                    break;
                }
            }finally {
                //4. 在finally块中解锁
                lock.unlock();
            }

        }
    }
}

执行结果：

Thread-0拿到了票10
Thread-1拿到了票9
Thread-1拿到了票8
Thread-1拿到了票7
Thread-0拿到了票6
Thread-0拿到了票5
Thread-0拿到了票4
Thread-0拿到了票3
Thread-0拿到了票2
Thread-0拿到了票1

synchronized与Lock的对比

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

5. 线程通信问题

线程的通信是指线程之间以何种机制来交换信息。在编程中，线程之间的通信机制有两种：共享内存和消息传递。

在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信，典型的共享内存通信方式就是通过共享对象进行通信。

在消息传递的并发模型里，线程之间没有公共状态，线程之间必须通过明确的发送消息来显式进行通信，在 Java 中典型的消息传递方式就是 wait() 和 notify()。

Java提供了几个方法解决线程之间的通信问题：

方法名作用
wait()表示线程一直等待，直到其他线程唤醒，与 sleep 不同，会释放锁
wait(long timeout)指定等待的毫秒数
notify()唤醒一个处于等待状态的线程
notifyAll()唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IllegalMonitorStateException

6. 线程池

  • 背景
    经常创建和销毁线程，会消耗大量的资源。比如并发情况下的线程，对性能影响很大。
  • 思路
    提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁线程，实现重复利用。类似生活中的公共交通工具。
  • 好处
    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理
      • corePoolSize：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止
  • JDK5.0 起提供了线程池相关API：ExecutorService和Executors
  • ExecutorService：真正的线程池接口。常见子类是ThreadPoolExecutor
    • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    • Future<T> submit(CaIIabIe<T> task)：执行任务有返回值，一般用来执行Callable
    • void shutdown()：关闭连接池
  • Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

使用示例

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

public class TestPool {
    public static void main(String[] args) {
        //1. 创建线程池
        //newFixedThreadPool的参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.submit(new MyThread());
        service.submit(new MyThread());
        service.submit(new MyThread());
        service.submit(new MyThread());

        //2. 关闭连接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
小谷围最靓的仔
关注
专栏目录
Java基础 多线程运用——统计文本中的各个单词出现次数
Alcaibur的博客
11-15 2100
统计文本中的各个单词出现次数，并将汇总数据保存到txt文件中。
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
最新发布
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4882
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java多线程（超详细！）
一只小菜鸡
05-13 13万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
JAVA多线程基本原理
m0_58355200的博客
04-10 1907
JAVA多线程 1. 什么是线程?线程和进程的区别? 进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当一个程序进入内存运行时，就成为一个进程。 线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。 主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
java基础多线程练习题（1）
08-08
总结来说，Java基础多线程练习题主要涵盖了线程的创建、同步与通信、线程安全以及并发工具的使用。通过这些题目，你可以更好地理解线程的工作原理，学会在实际项目中有效利用多线程提高程序性能，避免潜在的问题。在...
java基础多线程
05-18
学完以后我们应该可以: 了解什么是线程 编程定义线程 编程实例化线程 知道如何启动线程 会使用同步代码来保护资源 说出线程的4个状态之间的转换关系
【java基础】多线程
fxkcsdn的博客
08-20 128
Java中的多线程你只要看这一篇就够了 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文的范围之内。 用多线程只有一个目的，那就是更好的利用cpu的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应“...
【集合】遍历 List 集合的几种方式
小谷围最靓的仔
06-08 2万+
1. 初始化 List 集合 List<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); 2. 遍历 方式一：for循环 最基础的遍历方式：for循环，指定下标位置，使用 List 集合的 get(i) 方法来获取元素。 for(int i=0; i<list.size(); i++){ System.out.println(list.get(i)); } 方
cmd错误：找不到或无法加载主类 和 错误：找不到符号
小谷围最靓的仔
06-08 1万+
背景 在eclipse的文件目录： 这是我写的一个编程基于udp的Ping课设，PingClient.java文件是客户端，PingServer.java是服务器端，ThreadServer.java是服务器的线程，在PingServer.java中调用了ThreadServer.java！在eclipse中运行一切正常，没有任何错误！ 在文件资源管理器中的目录： 问题及解决方法 ...
【IDEA】2020.3.2版本的IntelliJ IDEA 新建项目HelloWorld示例（非Maven项目）
小谷围最靓的仔
02-24 2216
作为IDEA新手小白，我在网上找了好多教程，发现我的IDEA新建项目过程跟网上的不太一样，不知道是不是版本不一样的原因，特此记录 第一步：New Project 第二步：创建一个空项目 就是到这一步，我的页面跟网上的教程不太一样，甚至出现了报错：Error: library is not specified，我刚开始以为是我的安装环境出了问题，后来看到有的博主说， 是因为从2020.2.2版本开始，添加功能模块更改到了项目右键菜单上，项目右键选择Add Framework Support 即可 。 简而
【Java面试题】IO & NIO
小谷围最靓的仔
03-16 1651
1、什么是IO流？ 它是一种数据的流从源头流到目的地。比如文件拷贝，输入流和输出流。输入流从文件中读取数据存储到进程（process）中，输出流从进程中读取数据然后写入到目标文件。 2、Java中有几种类型的流？ 按照单位大小：字符流、字节流。 按照流的方向：输出流、输入流。 3、字节流和字符流哪个好？怎么选择？ 绝大多数情况下使用字节流会更好，因为字节流是字符流的包装，而大多数时候 IO 操作都是直接操作磁盘文件，所以这些流在传输时都是以字节的方式进行的〔图片等都是按字节存储的） 如果操作是需要通过
【Java面试题】多线程
小谷围最靓的仔
03-30 881
1、什么是进程？ 进程是系统中正在运行的一个程序，程序一旦运行就是进程。 进程可以看成程序执行的一个实例。进程是系统资源分配的独立实体，每个进程都拥有独立的地址空间。一个进程无法访问另一个进程的变量和数据结构，如果想让一个进程访问另一个进程的资源，需要使用进程间通信，比如管道，文件，套接字等。 2、什么是线程？ 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 3、线程的实
【Java面试题】基础知识
小谷围最靓的仔
03-13 671
1、java语言的三大特性 封装 继承extends 继承后的子类自动拥有父类的属性和方法，但是注意，父类的私有属性和构造方法并不能被继承。 子类也可以写自己特有的属性和方法，目的是实现功能的扩展。 子类也可以重写父类的方法。 多态：Parent p = new Child(); 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。 多态需要向上转型（upcast），其中向上转型是由JVM自动实现的、是安全的的。但向下转型（downcast）
【Java基础】基本数据类型、封装类、装箱、拆箱
小谷围最靓的仔
06-08 566
1. 基本数据类型及其封装类 基本类型 大小（字节） 默认值 封装类 byte 1 （byte）0 Byte short 2 （short）0 Short int 4 0 Integer long 8 0L Long float 4 0.0f Float double 8 0.0d Double boolean - false Boolean char 2 \u0000(null) Character 注意： boolean单独使用是占4个字节，在数组中又是
【Java面试题】JVM
小谷围最靓的仔
03-31 376
1、JDK、JRE、JVM关系？ JDK（Java Development Kit）：Java语言的软件开发包，包括 Java 运行时环境JRE。 JRE（Java Runtime Environment）Java运行时环境，包括JVM。 JVM（Java Virtual Machine）： 一种用于计算机设备的规范。 Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值