Java多线程

多线程

1 多线程概述

1.1 线程与进程

进程：

是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程：

• 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
• 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

1.2 线程调度

分时调度

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

抢占式调度

• 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
• CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使用率更高。

1.3 同步&异步

同步：排队执行 , 效率低但是安全。

异步：同时执行 , 效率高但是数据不安全。

1.4 并发&并行

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

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

2 多线程的实现

2.1 继承Thread

2.1.1 Thread类

构造方法：

Thread() 
Thread(String name)
Thread(Runnable target) 
Thread(Runnable target, String name) 

其中name是线程的名称

常用方法：

long getId() 

返回此Thread的标识符。

String getName() 

返回此线程的名称。

void start() 

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

void stop() 

这种方法本质上是不安全的。 现在应该是通知线程该结束了，然后让线程自杀。比如定义一个flag执行时不断观察这个flag，如果flag变成false了就从run方法中return

static void sleep(long millis) 

导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。

static void sleep(long millis, int nanos) 

导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。

void setDaemon(boolean on) 

将此线程标记为 daemon（守护） 线程或用户线程。 用户线程是自己决定自己的死亡，守护线程是当所有用户线程死亡后自动死亡。

字段：

static int MAX_PRIORITY 

线程可以拥有的最大优先级。

static int MIN_PRIORITY 

线程可以拥有的最低优先级。

static int NORM_PRIORITY 

分配给线程的默认优先级。

2.1.2 具体实现

1.创建自定义类继承Thread
2.重写run方法，并在run方法中实现线程的执行逻辑
3.创建自定义类的对象，在执行其start方法

public class MyThread extends Thread {
    //run方法就是线程要执行的任务方法
    @Override
    public void run() {
        //这里的代码就是一条新的执行路径
        //这个执行路径是触发方式，不是调用run方法，而是通过thread对象的start方法来启动任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {

        MyThread m = new MyThread();
        m.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("汗滴禾下土"+i);
        }
}

每个线程都拥有自己的栈空间，线程中的方法就在自己的栈空间内，共用一份堆内存。

匿名内部类的实现方式：

1.new Thread(){重写其run方法} 获取到对象并对其进行start

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

2.2 实现Runnable接口

1.创建自定义类实现其接口
2.重写run方法
3.创建Thread对象，并将自定义类对象传入Thread构造方法中
4.通过Thread对象调用start方法

实现接口的这个类可以看成是一个任务类：

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("锄禾日当午"+i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //实现runnable
        //1 创建一个任务对象
        MyRunnable r = new MyRunnable();
        //创建一个线程并给他一个任务
        Thread t = new Thread(r);
        //启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("汗滴禾下土"+i);
        }
    }
}

实现Runnable与继承Thread相比有如下优势：

1.通过创建任务，然后给线程分配任务的方式实现多线程，更适合多个线程同时执行任务的情况

2，可以避免单继承所带来的局限性

3，任务与线程是分离的，提高了程序的健壮性

4，后期学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的线程

使用匿名内部类实现

1.new Thread (new Runable 匿名内部类对象传入)之后进行start启动

new Thread(new Runable(){
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("12345"+i);
        }
    }
}).start();

2.3实现Callable接口（见下文 )

3 线程操作

3.1 设置和获取线程名称

Thread.currentThread().getName()
public class Demo3 {
    public static void main(String[] args) {
        //如何获取线程的名称
        System.out.println(Thread.currentThread().getName());
        //两种设置线程名称的方式
        Thread t = new Thread(new MyRunnable());
        t.setName("wwww");
        t.start();
        new Thread(new MyRunnable(),"锄禾日当午").start();
        //不设置的有默认的名字
        new Thread(new MyRunnable()).start();
    }
    
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

执行结果：

3.2 线程休眠

public static void main(String[] args) throws InterruptedException {
    //线程的休眠
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
        Thread.sleep(1000);     //1000毫秒
    }
}

3.3 线程阻塞

一般比较耗时的操作都可以看成线程阻塞，比如文件的读取、接收用户输入

也被称为耗时操作。

3.4 线程的中断

一个线程是一个独立的执行路径，它是否结束应该由其自身决定。

可以给线程打上标记，中断时会有一个异常，程序员可以在catch块中处理决定是否让其死亡。

例：主线程执行完毕后给t1线程添加一个中断标记

public class Demo5 {
    public static void main(String[] args) {
        //线程中断
        //一个线程是一个独立的执行路径，它是否结束应该由其自身决定
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //给线程t1添加中断标记
        t1.interrupt();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    System.out.println("发现了中断标记，线程自杀");
                    return;
                }
            }
        }
    }
}

在sleep时会检查是否有InterruptedException

3.5 守护线程

线程分为守护线程和用户线程

• 用户线程：当一个进程不包含任何的存活的用户线程时，进行结束。
• 守护线程:守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

public class Demo6 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        //设置守护线程（主线程死亡时t1就死亡）
        t1.setDaemon(true);
        t1.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.6 其他常用方法

1.获取线程名称
	Thread.currentThread() 获取到当前正在执行的线程对象，之后再执行其getName方法
	2.可以使用 this.getName获取
2.设置线程名称
	1.new Thread(Runnable接口实现对象,"名称")
	2. 创建一个继承了Thread类的对象，通过其构造方法 进行传递，在构造方法中使用 super(线程名变量)
	3.使用Thread对象.setName添加
3.start 用于启动一个线程，执行run方法中的逻辑
4.sleep  给定一个倒计时时间阻塞当前线程
5.join 当给定的线程使用join之后，该线程会一直占用当前CPU的执行权，直到其线程死亡，释放CPU的执行权
6.yield 当程序执行到该方法时，会将当前线程的CPU执行权进行释放，再进行下一轮的CPU执行权的竞争
7.stop 当被调用时，当前线程执行结束，并不影响其他线程执行
8.interrupt 对于该方法执行后，不会像stop方法立即终止当前线程，而是会等待一小段时间后，再去停止线程
9.setDaemon 对于守护线程，也称为后台线程，当该线程执行完成后，整个应用程序退出

4 线程安全

4.1 不安全例子

多个线程争抢同一个变量

买票程序：

public class Demo7 {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 5;
        @Override
        public void run() {
            while (count>0){
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

4.2 线程安全——同步代码块

格式：

synchronized（锁对象）{

}

java中任何对象都可以作为锁对象。

注意所有线程一定要看同一把锁。

public class Demo8 {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Object o = new Object();
        @Override
        public void run() {
            //Object o = new Object();    //这里不是同一把锁，所以锁不住
                while (true) {
                    synchronized (o) {
                        if (count > 0) {
                         //卖票
                            System.out.println("正在准备卖票");
                            try {
                            Thread.sleep(1000);
                            } catch (InterruptedException e) {
                            e.printStackTrace();
                            }
                            count--;
                            System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                        }else {
                            break;
                        }

                }
            }
        }
    }
}

4.3 线程安全——同步方法

以方法为单位进行加锁。但必须是对同一个任务runnable进行加锁才有效果。

public class Demo9 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案2  同步方法
        Runnable runnable = new Ticket();
        new Thread(runnable).start();
        new Thread(runnable).start();
        new Thread(runnable).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        @Override
        public void run() {
            while (true) {
                boolean flag = sale();
                if(!flag){
                    break;
                }
            }
        }
        
        public synchronized boolean sale(){
            if (count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                return true;
            }
                return false;
        }
    }
}

4.4 线程安全——显式锁Lock

同步代码块和同步方法都属于隐式锁。

显式锁 Lock 子类 ReentrantLock

public class Demo10 {
    public static void main(String[] args) {
        //线程不安全
        //解决方案1   显示锁  Lock  子类 ReentrantLock

        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //总票数
        private int count = 10;
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                l.lock();
                    if (count > 0) {
                        //卖票
                        System.out.println("正在准备卖票");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count--;
                        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                    }else {
                        break;
                    }
                l.unlock();
            }
        }
    }
}

4.5 公平锁与不公平锁

公平锁：先来等待的先执行

不公平锁：解锁后大家一起抢

创建公平锁：

Lock l = new ReentrantLock(true);

4.6 线程死锁

简单来说就是A等B，B等A

public class Demo11 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }

    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }

        @Override
        public void run() {
            p.say(c);
        }
    }
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
            p.fun();
        }
        public synchronized void fun(){
            System.out.println("罪犯被放了，罪犯也放了人质");
        }
    }
    static class Police{
        public synchronized void say(Culprit c){
            System.out.println("警察：你放了人质，我放了你");
            c.fun();
        }
        public synchronized void fun(){
            System.out.println("警察救了人质，但是罪犯跑了");
        }
    }
}

解决方法：在任何有可能导致锁产生的方法里，不要再调用另一个方法让锁产生。

小结

1.Synchronized
	成员方法 对当前对象进行加锁操作 
		优缺点：可以直接对当前对象进行加锁，缺点是要求当前对象只能有一个 比较清晰简介
	静态方法 对当前方法的类进行加锁，类加锁后其类产生的对象也会被加锁 
		优缺点：静态方法的类进行加锁,其对象可以有很多个 
	同步代码块 可以指定具体的对象进行加锁操作
		优缺点：可以指定任意一个对象进行加锁，需要对对象进行传递，并且对象只能有一个 
2.使用lock和Unlock方法 获取 Lock类的子类之后，对对象调用lock方法，当前lock和Unlock之间的程序会被加锁 

5 多线程通信

Object类中存在以下方法：

void notify() 

唤醒正在此对象监视器上等待的单个线程。

void notifyAll() 

唤醒等待此对象监视器的所有线程。

void wait() 

导致当前线程等待它被唤醒，通常是 通知 或 中断 。

void wait(long timeoutMillis) 

导致当前线程等待它被唤醒，通常是 通知 或 中断 ，或者直到经过一定的时间。

void wait(long timeoutMillis, int nanos) 

导致当前线程等待它被唤醒，通常是 通知或 中断 ，或者直到经过一定的时间。

必须用同一个对象来中断或唤醒某个线程。

5.1 生产者消费者问题

A生产数据，B要用A生产的数据使用。

设计厨师类和服务员类都实现多线程和一个食物类，一个生产食物，另一个消费食物。

厨师做完菜之后叫醒服务员端菜，然后厨师睡着；服务员端完菜之后叫醒厨师做菜然后睡着。

public class Demo12 {
    public static void main(String[] args) {
        //多线程通信    生产者与消费者问题
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    /**
     * 厨师类，调用set
     */
    static class Cook extends Thread{
        private Food f;

        public Cook(Food f) {
            this.f = f;
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) { // 循环生产100份菜
                if(i%2==0){
                    f.setNameAndTaste("小米粥","甜味");
                }else {
                    f.setNameAndTaste("煎饼果子","甜辣味");
                }
            }
        }

    }

    /**
     * 服务员类，调用get
     */
    static class Waiter extends Thread{
        private Food f;

        public Waiter(Food f) {
            this.f = f;
        }

        @Override
        public void run() { // 循环取出100份菜
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }

    }

    /**
     * 食物类
     */
    static class Food{
        private String name;
        private String taste;
        //true表示可以做菜
        boolean flag = true;

        /**
         * 生产方法
         * @param name
         * @param taste
         */
        public synchronized void setNameAndTaste(String name,String taste){
            if(flag){
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;   // 做完菜之后不能再做菜了

                this.notifyAll();   // 叫醒服务员
                try {
                    this.wait();    // 自己睡过去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        /**
         * 消费方法
         */
        public synchronized void get(){
            if(!flag){
                System.out.println("服务员端走的菜的名称是："+name+",味道是："+taste);
                flag = true;    // 让厨师开始做菜

                this.notifyAll();   // 把厨师唤醒
                try {
                    this.wait();    // 自己睡过去
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

6 线程组

线程组（Thread Group）是Java中用于管理和控制一组线程的机制。它是java.lang.ThreadGroup类的实例，可以包含多个线程和子线程组。使用线程组可以方便地进行批量操作、统一管理和控制一组线程。

下面是线程组的一些常用特性和用法：

1. 组织和管理线程：线程组可以将一组相关的线程组织在一起，方便集中管理。通过将线程放入线程组，可以批量创建、启动、停止和销毁线程，而不需要逐个处理每个线程。
2. 线程隔离：线程组可以提供一种逻辑上的隔离，每个线程组中的线程彼此独立运行，不会受到其他线程组的影响。这有助于组织和分析线程的执行情况，以及控制线程运行的环境。
3. 异常处理：可以为线程组设置统一的异常处理器（UncaughtExceptionHandler），来处理线程组中线程抛出的未捕获异常，避免异常传播到线程组外部。
4. 线程优先级管理：线程组可以设置一个默认的优先级，所有的线程在该线程组中运行时都会继承该默认优先级。这可以方便地管理线程的优先级，避免再次单独设置每个线程的优先级。
5. 递归遍历：线程组可以包含其他线程组，形成层次结构。这使得可以递归遍历整个线程组层次结构，查看和操作每个线程和子线程组。

以下是线程组的一些常用方法：

• ThreadGroup(String name)：创建一个具有指定名称的线程组。
• void addThread(Thread t)：将指定的线程添加到线程组中。
• void removeThread(Thread t)：从线程组中移除指定的线程。
• void destroy()：销毁线程组，停止组内所有的线程。
• void setDaemon(boolean isDaemon)：设置线程组是否为守护线程组。
• void setMaxPriority(int pri)：设置线程组的最高优先级。
• void uncaughtException(Thread t, Throwable e)：线程组的默认未捕获异常处理器。

使用线程组可以方便地管理和控制一组线程，特别是在需要批量操作或对线程进行分组管理时，线程组是一个非常有用的工具。

线程的六种状态

线程可以处于以下状态之一：

• NEW

尚未启动的线程处于此状态。

• RUNNABLE

在Java虚拟机中执行的线程处于此状态。

• BLOCKED

被阻塞等待监视器锁定的线程处于此状态。

• WAITING

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

• TIMED_WAITING

正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。

• TERMINATED

已退出的线程处于此状态。

7 带返回值的线程Callable

7.1 Runnable 与 Callable

接口定义：

//Callable接口
public interface Callable<V> {
    V call() throws Exception;
}

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

7.2 Callable使用步骤

使用Callable接口的步骤通常包括以下几个：

(使用线程池)

1. 创建实现Callable接口的类： 创建一个类，实现Callable接口，并重写call方法。call方法类似于Runnable的run方法，但它可以返回结果，并抛出受检异常。

   import java.util.concurrent.Callable;
   
   public class MyCallable implements Callable<Integer> {
       @Override
       public Integer call() throws Exception {
           // 执行一些计算或任务，并返回结果
           return 42;
       }
   }
   

2. 创建ExecutorService： 使用ExecutorService框架创建一个线程池，以便异步执行Callable任务。

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class CallableExample {
       public static void main(String[] args) {
           // 创建一个线程池
           ExecutorService executorService = Executors.newSingleThreadExecutor();
       }
   }
   

   在这个例子中，使用了newSingleThreadExecutor()方法创建一个单线程的线程池，你也可以选择其他类型的线程池，如newFixedThreadPool()或newCachedThreadPool()，具体取决于你的需求。

3. 提交Callable任务： 使用submit方法提交Callable任务给线程池，并获得Future对象。

   import java.util.concurrent.Future;
   
   public class CallableExample {
       public static void main(String[] args) {
           // 创建一个线程池
           ExecutorService executorService = Executors.newSingleThreadExecutor();
   
           // 创建Callable实例
           MyCallable myCallable = new MyCallable();
   
           // 提交Callable实例给线程池，并获取Future对象
           Future<Integer> future = executorService.submit(myCallable);
       }
   }
   

4. 处理任务结果： 使用Future对象可以获取Callable任务的执行结果。

   import java.util.concurrent.Future;
   
   public class CallableExample {
       public static void main(String[] args) {
           // 创建一个线程池
           ExecutorService executorService = Executors.newSingleThreadExecutor();
   
           // 创建Callable实例
           MyCallable myCallable = new MyCallable();
   
           // 提交Callable实例给线程池，并获取Future对象
           Future<Integer> future = executorService.submit(myCallable);
   
           try {
               // 获取Callable任务的执行结果
               Integer result = future.get();
               System.out.println("Result: " + result);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

5. 关闭线程池： 在任务执行完毕后，记得关闭线程池以释放资源。

   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class CallableExample {
       public static void main(String[] args) {
           // 创建一个线程池
           ExecutorService executorService = Executors.newSingleThreadExecutor();
   
           // 创建Callable实例
           MyCallable myCallable = new MyCallable();
   
           // 提交Callable实例给线程池，并获取Future对象
           executorService.submit(myCallable);
   
           // 关闭线程池
           executorService.shutdown();
       }
   }
   

（不使用线程池）

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);

3. 通过Thread,启动线程

new Thread(future).start();

7.3 Runnable 与 Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

7.4 Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不能抛出

7.5 Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

8 线程池 Executors

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
public static ExecutorService newCachedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future<?> submit(Runnable task)
Future submit(Callable task)
案例演示

在Java中，你可以使用ExecutorService和ThreadPoolExecutor来创建线程池对象，以及通过Runnable接口创建任务并提交给线程池。以下是一个简单的示例：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池，其中包含5个线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 创建Runnable实例
        Runnable myRunnable = new MyRunnable();

        // 提交Runnable实例给线程池
        executorService.submit(myRunnable);

        // 关闭线程池
        executorService.shutdown();
    }
}

// 自定义Runnable实现
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Executing my task in a separate thread");
    }
}

在这个例子中，Executors.newFixedThreadPool(5)创建了一个包含5个线程的线程池。然后，我们创建了一个MyRunnable实例，并通过executorService.submit(myRunnable)提交给线程池。最后，通过executorService.shutdown()关闭线程池。确保在程序结束时关闭线程池，以释放资源。

Callable接口是与Runnable相似的接口，但有一个重要的区别。Callable的call()方法可以返回结果，并且可以抛出异常。与之相对比，Runnable的run()方法不能返回结果，也不能抛出受检异常。

下面是一个使用Callable的简单示例：

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

public class CallableExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池，其中包含5个线程
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 创建Callable实例
        Callable<Integer> myCallable = new MyCallable();

        // 提交Callable实例给线程池
        Future<Integer> future = executorService.submit(myCallable);

        try {
            // 获取任务的结果
            Integer result = future.get();
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

// 自定义Callable实现
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Executing my task in a separate thread");
        // 模拟一些计算任务，并返回结果
        return 42;
    }
}

在这个例子中，MyCallable实现了Callable<Integer>接口，其中call()方法执行具体的任务并返回一个整数结果。我们使用ExecutorService提交MyCallable的实例，得到一个Future对象，通过该对象可以获取任务执行的结果。最后，通过executorService.shutdown()关闭线程池。

8.1 线程池的好处

• 降低资源消耗。
• 提高响应速度。
• 提高线程的可管理性。

8.2 Java中的四种线程池 ExecutorService

8.2.1 缓存线程池

public static void main(String[] args) {
   
    /**
    * 缓存线程池.
    * (长度无限制)
    * 执行流程:
    *     1. 判断线程池是否存在空闲线程
    *     2. 存在则使用
    *     3. 不存在,则创建线程 并放入线程池, 然后使用
    */
    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()+"锄禾日当午");
        }
    });

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

8.2.2 定长线程池

public static void main(String[] args) {
    ExecutorService service = Executors.newFixedThreadPool(2);
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    });
    service.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"锄禾日当午");
        }
    });
}

线程池长度只有2，所以第三行要在sleep了3秒以后才会执行。

8.2.3 单线程线程池

public class Demo15 {
    /*单线程线程池
    执行流程
        1 判断线程池的那个线程是否空闲
        2 空闲则使用
        3 不空闲则等待它空闲后再使用
    **/
    public static void main(String[] args) {
        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()+"锄禾日当午");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
            }
        });
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jnI28cbX-1598593740238)(C:\Users\Faker\Desktop\123.assets\clipboard (5)].png)

8.2.4 周期性任务定长线程池

定时执行一次：

//参数1：定时执行的任务
//参数2：时长数字
//参数3：2的时间单位    Timeunit的常量指定
scheduledExecutorService.schedule(new Runnable() {
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"锄禾日当午");
     }
 },5, TimeUnit.SECONDS);      //5秒钟后执行*/

周期性执行：

/*
周期性执行任务
    参数1：任务
    参数2：延迟时长数字（第一次在执行上面时间以后）
    参数3：周期时长数字（没隔多久执行一次）
    参数4：时长数字的单位
* **/
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"锄禾日当午");
    }
},5,1,TimeUnit.SECONDS);

9定时器

在 Java 中，你可以使用 Timer 类来创建定时器，该类允许你调度任务在未来的某个时间执行，也可以按照固定的时间间隔执行任务。

以下是使用 Timer 的基本示例：

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();

        // 创建一个延迟执行的任务
        TimerTask task1 = new MyTimerTask("Task 1");
        timer.schedule(task1, 1000); // 在1秒后执行

        // 创建一个重复执行的任务，每隔2秒执行一次
        TimerTask task2 = new MyTimerTask("Task 2");
        timer.scheduleAtFixedRate(task2, 2000, 2000);

        // 让主线程休眠一段时间，以观察定时任务的执行
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 取消定时器
        timer.cancel();
    }
}

class MyTimerTask extends TimerTask {
    private String taskName;

    public MyTimerTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println("Executing " + taskName + " at " + System.currentTimeMillis());
    }
}

在这个例子中，我们创建了一个 Timer 对象，然后使用 schedule 方法安排了一个延迟执行的任务 task1，以及使用 scheduleAtFixedRate 方法安排了一个每隔2秒执行一次的重复任务 task2。最后，让主线程休眠一段时间，以观察定时任务的执行，然后取消定时器。

请注意，Timer 类在某些情况下可能不适合高度并发的场景，因为它是基于单个线程的。在更复杂的应用中，你可能会考虑使用 ScheduledExecutorService 接口的实现，如 ScheduledThreadPoolExecutor，它提供了更强大的定时任务调度机制。

10多线程面试题

多线程的实现方案：

1. 继承 Thread 类： 创建一个类继承 Thread 类，重写 run 方法，并通过创建该类的实例来启动线程。

   javaCopy codeclass MyThread extends Thread {
       public void run() {
           // 线程执行的逻辑
       }
   }
   
   // 启动线程
   MyThread myThread = new MyThread();
   myThread.start();
   

2. 实现 Runnable 接口： 创建一个类实现 Runnable 接口，实现 run 方法，并通过创建 Thread 对象传入 Runnable 对象来启动线程。

   javaCopy codeclass MyRunnable implements Runnable {
       public void run() {
           // 线程执行的逻辑
       }
   }
   
   // 启动线程
   MyRunnable myRunnable = new MyRunnable();
   Thread thread = new Thread(myRunnable);
   thread.start();
   

3. 实现 Callable 接口： 创建一个类实现 Callable 接口，实现 call 方法，通过 ExecutorService 提交 Callable 任务来启动线程。

   javaCopy codeimport java.util.concurrent.Callable;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   import java.util.concurrent.Future;
   
   class MyCallable implements Callable<Integer> {
       public Integer call() throws Exception {
           // 线程执行的逻辑
           return 42;
       }
   }
   
   // 启动线程
   ExecutorService executorService = Executors.newSingleThreadExecutor();
   Future<Integer> future = executorService.submit(new MyCallable());
   

同步的方式：

1. Synchronized 方法： 使用 synchronized 关键字修饰方法，确保同一时刻只有一个线程能够执行该方法。

   javaCopy codepublic synchronized void synchronizedMethod() {
       // 同步的方法逻辑
   }
   

2. Synchronized 块： 使用 synchronized 关键字修饰一个代码块，确保同一时刻只有一个线程能够执行该代码块。

   javaCopy codepublic void someMethod() {
       synchronized (lockObject) {
           // 同步的代码块逻辑
       }
   }
   

3. Lock 接口： 使用 java.util.concurrent.locks.Lock 接口的实现类，如 ReentrantLock，来实现锁。

   javaCopy codeimport java.util.concurrent.locks.Lock;
   import java.util.concurrent.locks.ReentrantLock;
   
   Lock lock = new ReentrantLock();
   
   public void someMethod() {
       lock.lock();
       try {
           // 同步的逻辑
       } finally {
           lock.unlock();
       }
   }
   

线程的启动：

• run 方法： 直接调用 run 方法是普通的方法调用，不会启动新线程，会在当前线程中执行 run 方法的代码。

  javaCopy code
  myThread.run();
  

• start 方法： 调用 start 方法才会启动新线程，会在新线程中执行 run 方法的代码。

  javaCopy code
  myThread.start();
  

sleep() 和 wait() 方法的区别：

1. sleep()： 是 Thread 类的静态方法，用于让当前线程休眠指定的时间，不会释放锁。主要用于暂停执行，模拟时间的流逝。

   javaCopy code
   Thread.sleep(1000); // 休眠1秒
   

2. wait()： 是 Object 类的方法，用于让当前线程等待，释放对象的锁。通常与 notify() 和 notifyAll() 一起使用，用于线程间的协调和通信。

   javaCopy codesynchronized (lockObject) {
       lockObject.wait(); // 等待，释放锁
   }
   

wait(), notify(), notifyAll() 方法在 Object 类中的原因：

这是因为 wait(), notify(), 和 notifyAll() 方法需要和对象的监视器（锁）一起使用。这些方法在调用时必须在同步块或同步方法中执行，因为它们需要获取对象的监视器，而对象的监视器是由 synchronized 关键字提供的。

线程的生命周期图：

线程的生命周期通常包括以下几个状态：

1. New（新建）： 线程刚被创建，但还未启动。
2. Runnable（可运行）： 线程被启动，等待 CPU 时间片。
3. Blocked（阻塞）： 线程被阻塞，等待获取一个监视器锁。
4. Waiting（等待）： 线程处于等待状态，等待其他线程调用 notify() 或 notifyAll()。
5. Timed Waiting（定时等待）： 线程在等待一段时间后会自动唤醒。
6. Terminated（终止）： 线程执行完成，或者因异常退出。

具体线程的状态会随着线程的执行和外部事件的发生而发生改变，形成不同的生命周期。

11设计模式

设计模式概述：

设计模式是一套经过反复验证、使用和总结的、用来解决特定场景下一般性问题的经验性设计原则、解决方案集合。它提供了一种在设计过程中解决常见问题的方法，并提高了代码的可维护性和可重用性。设计模式并不是一种可直接转化为代码的模板，而是一种解决问题的思想、方法。

什么是设计模式：

设计模式是对软件设计中常见问题的一种通用且经过验证的解决方案。它不是一个可直接转化为代码的具体实现，而是一种面向对象设计原则和思想的应用。设计模式提供了一套共享的词汇和一些通用概念，帮助开发人员更好地理解和沟通。

设计模式分类：

设计模式可以分为三类：

创建型模式（Creational Patterns）： 主要关注对象的创建机制。这包括对象的实例化方式、初始化过程以及对象的组合方式。创建型模式有：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式等。

行为型模式（Behavioral Patterns）： 关注对象之间的通信、职责分配、算法和状态等行为。行为型模式有：观察者模式、策略模式、模板方法模式、命令模式、责任链模式等。

结构型模式（Structural Patterns）： 关注类和对象的组合，以形成更大的结构。结构型模式有：适配器模式、装饰器模式、代理模式、组合模式、桥接模式等。

创建型模式：

单例模式（Singleton Pattern）： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。

工厂模式（Factory Pattern）： 定义一个用于创建对象的接口，由子类决定实例化哪一个类。

抽象工厂模式（Abstract Factory Pattern）： 提供一个接口，用于创建与产品家族相关的对象，而不需要指定具体类。

建造者模式（Builder Pattern）： 将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

原型模式（Prototype Pattern）： 用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

行为型模式：

观察者模式（Observer Pattern）： 定义一对多的依赖关系，使得当一个对象状态改变时，所有依赖它的对象都会得到通知并更新。

策略模式（Strategy Pattern）： 定义一系列算法，将它们封装起来，并且使它们可以相互替换。

模板方法模式（Template Method Pattern）： 定义一个算法的骨架，而将一些步骤延迟到子类中。

命令模式（Command Pattern）： 将请求封装成对象，使得可以用不同的请求对客户进行参数化。

责任链模式（Chain of Responsibility Pattern）： 为请求创建一个接收者对象的链，并将请求沿着这条链传递，直到有一个对象处理它。

结构型模式：

适配器模式（Adapter Pattern）： 将一个类的接口转换成客户希望的另一个接口，使得原本不兼容的类可以一起工作。

装饰器模式（Decorator Pattern）： 动态地给一个对象添加一些额外的职责，而不影响其他对象。

代理模式（Proxy Pattern）： 为其他对象提供一种代理以控制对这个对象的访问。

组合模式（Composite Pattern）： 将对象组合成树形结构以表示"部分-整体"的层次结构。

桥接模式（Bridge Pattern）： 将抽象部分与它的实现部分分离，使它们都可以独立地变化。

以上设计模式提供了一种通用的解决方案，可以在软件设计中应对常见的问题，提高代码的灵活性、可维护性和可扩展性。在实际应用中，根据具体的场景和问题，选择合适的设计模式能够更好地解决问题。

12 单例设计模式

单例设计模式的目的是确保类在内存中只有一个实例，并提供一个全局访问点。为了实现这个目标，可以采取以下步骤：

1. 构造私有（Private Constructor）： 将类的构造方法设为私有，这样外部就无法直接通过 new 关键字来创建该类的实例。
2. 本身提供一个对象： 在类的内部，创建一个私有的静态成员变量，用于保存类的唯一实例。该实例通常是在类加载时就创建好的。
3. 通过公共方法让外界访问： 提供一个公共的静态方法，允许外部访问类的唯一实例。在该方法中，首先判断实例是否已经创建，如果已经创建则直接返回该实例，否则先创建再返回。

以下是一个经典的单例模式的示例代码：

public class Singleton {
    // 私有静态成员变量，用于保存类的唯一实例
    private static Singleton instance;

    // 私有构造方法，防止外部直接实例化
    private Singleton() {
        // 构造方法内容
    }

    // 公共的静态方法，提供对类的唯一实例的访问
    public static Singleton getInstance() {
        // 判断实例是否已经创建
        if (instance == null) {
            // 若未创建，则创建实例
            instance = new Singleton();
        }
        // 返回实例
        return instance;
    }

    // 其他成员方法...
}

这样，通过调用 Singleton.getInstance() 方法，外部代码可以获得类的唯一实例，而且该实例在整个应用程序生命周期内只会被创建一次。在多线程环境下，需要注意使用线程安全的方式创建实例，例如使用双重检查锁定（Double-Checked Locking）或者静态内部类等方式来确保线程安全。

13单例设计模式分类

饿汉式（开发阶段使用）：

饿汉式是指在类加载的时候就创建实例，并在类的内部直接提供一个实例。它的实现方式简单直接，适用于实例创建较为简单且在整个生命周期内都会被使用的情况。

public class Singleton {
    // 在类加载时就创建实例
    private static final Singleton instance = new Singleton();

    // 私有构造方法，防止外部直接实例化
    private Singleton() {
        // 构造方法内容
    }

    // 提供对类的唯一实例的访问
    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式天生是线程安全的，因为在类加载时就已经创建了实例，不存在多线程并发访问导致创建多个实例的问题。

懒汉式（面试阶段使用）：

懒汉式是指在需要获取实例的时候才进行实例的创建，懒加载思想。懒汉式可能存在多线程并发访问时创建多个实例的问题，因此在多线程环境下需要考虑线程安全。

懒汉式（线程不安全）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 构造方法内容
    }

    public static Singleton getInstance() {
        if (instance == null) {
            // 若实例未创建，则创建实例
            instance = new Singleton();
        }
        return instance;
    }
}

该实现在多线程环境下可能会导致多个线程同时判断 instance == null 为真，从而创建多个实例，不是线程安全的。

懒汉式（线程安全，但效率较低）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 构造方法内容
    }

    public synchronized static Singleton getInstance() {
        if (instance == null) {
            // 若实例未创建，则创建实例
            instance = new Singleton();
        }
        return instance;
    }
}

通过在 getInstance 方法上加上 synchronized 关键字，可以确保在同一时刻只有一个线程能够执行该方法，从而保证线程安全。但是由于加锁会降低性能，因此这种方式效率较低。

懒汉式（双重检查锁定，Double-Checked Locking）：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 构造方法内容
    }

    public static Singleton getInstance() {
        if (instance == null) {
            // 双重检查锁定
            synchronized (Singleton.class) {
                if (instance == null) {
                    // 若实例未创建，则创建实例
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

通过在内部进行双重检查锁定，可以在保证线程安全的同时减小锁的范围，提高效率。同时使用 volatile 关键字来确保变量的可见性。

懒加载思想（延迟加载）：

懒加载是指在需要的时候才创建实例，可以通过懒汉式的方式实现。懒加载的优点是避免了不必要的资源浪费，只有在需要的时候才进行实例的创建。