java-多线程笔记-CSDN博客

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

（3）Thread的常用API

方法名称	说明
String getName()	获取当前线程的名称，默认线程名称是Thread-索引
void setName(String name)	设置线程名称
public static Thread currentThread()：	返回对当前正在执行的线程对象的引用
public static void sleep(long time)	让线程休眠指定的时间，单位为毫秒。
public void run()	线程任务方法
public void start()	线程启动方法

2.多线程的实现方案一：继承Thread类

（1）步骤

a.定义一个子类MyThread继承Thread类，重写run()方法

b.创建MyThread类的对象

c.调用线程对象的start()方法启动线程（启动后还是执行run方法的）

（2）优缺点

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

（3）为什么不直接调用run方法，而是调用start启动线程？

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。

只有调用start方法才是启动一个新的线程执行。

（4）代码演示

package d1_create;

public class ThreadDemo1 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程(执行的还是run方法)
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出:" + i);
        }
    }
}

/**
 * 1.定义一个线程类继承Thread类
 */
class MyThread extends Thread {
    /**
     * 2.重写run方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出:" + i);
        }
    }
}

3.多线程的实现方案二：实现Runnable接口

（1）步骤

a.定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

b.创建MyRunnable任务对象

c.把MyRunnable任务对象交给Thread处理

d.调用线程对象的start()方法启动线程

（2）优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

（3）代码演示

package d1_create;

public class ThreadDemo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new MyRunnable();
        //4.把任务对象交给Thread处理
//        Thread t = new Thread(target);
        Thread t = new Thread(target,"1号");
        //5.启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出:" + i);
        }
    }
}

/**
 * 1.定义一个线程任务类 实现Runnable接口
 */
class MyRunnable implements Runnable {

    /**
     * 2.重写run方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出:" + i);
        }
    }
}

匿名内部类形式：

package d1_create;

public class ThreadDemo2Other {
    public static void main(String[] args) {
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出:" + i);
                }
            }
        };
        Thread t = new Thread(target);
        t.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出:" + i);
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程3执行输出:" + i);
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出:" + i);
        }
    }
}

3.多线程的实现方案三：利用Callable、FutureTask接口实现

（1）步骤

a.得到任务对象

定义类实现Callable接口，重写call方法，封装要做的事情。

用FutureTask把Callable对象封装成线程任务对象。

b.把线程任务对象交给Thread处理。

c.调用Thread的start方法启动线程，执行任务

d.线程执行完毕后，通过FutureTask的get方法去获取任务执行的结果。

（2）FutureTask的API

方法名称	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象。
public V get() throws Exception	获取线程执行call方法返回的结果。

（3）优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。可以在线程执行完毕后去获取线程执行的结果。

缺点：编码复杂一点。

（4）代码演示

package d1_create;

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

public class ThreadDemo3 {
    public static void main(String[] args) {
        //3.创建Callable任务对象
        Callable<String> call = new MyCallable(100);
        //4.把Callable任务对象 交给FutureTask对象
        //FutureTask对象的作用1:是Runnable的对象(实现了Runnable接口),可以交给Thread了
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();


        Callable<String> call2 = new MyCallable(200);
        //4.把Callable任务对象 交给FutureTask对象
        //FutureTask对象的作用1:是Runnable的对象(实现了Runnable接口),可以交给Thread了
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            String rs1 = f1.get();
            System.out.println("第一个结果:" + rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            String rs2 = f2.get();
            System.out.println("第一个结果:" + rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 * 1.定义一个任务类 实现Callable接口 一个申明线程任务执行完毕后的结果的数据类型
 */
class MyCallable implements Callable<String> {
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    /**
     * 2.重写call方法(任务方法)
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是:" + sum;
    }
}

三、线程同步

1.线程安全问题

多个线程同时操作同一个共享资源的时候可能会出现业务安全问题，称为线程安全问题。

2.线程同步的核心思想

加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

3.方式一：同步代码块

（1）作用

把出现线程安全问题的核心代码给上锁。

（2）原理

每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

（3）锁对象的规范要求

规范上：建议使用共享资源作为锁对象。

对于实例方法建议使用this作为锁对象。

对于静态方法建议使用字节码（类名.class）对象作为锁对象。

（4）代码演示

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        synchronized (this) {
            if (this.money >= money) {
                System.out.println(name + "来取钱,吐出:" + money);
                this.money -= money;
                System.out.println(name + "取钱后,剩余:" + this.money);
            } else {
                System.out.println(name + "无法取钱,余额不足");
            }
        }
    }

4.方式二：同步方法

（1）作用

把出现线程安全问题的核心方法给上锁。

（2）原理

每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

（3）底层原理

同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！

如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

（4）代码演示

    public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();

        if (this.money >= money) {
            System.out.println(name + "来取钱,吐出:" + money);
            this.money -= money;
            System.out.println(name + "取钱后,剩余:" + this.money);
        } else {
            System.out.println(name + "无法取钱,余额不足");
        }
    }

5.方式三：Lock锁

Lock是接口，不能实例化，采用它的实现类ReentrantLock来构建Lock锁对象。

（1）Lock的API

方法名称	说明
void lock()	获得锁
void unlock()	释放锁

（2）代码演示

    public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        lock.lock();
        try {
            if (this.money >= money) {
                System.out.println(name + "来取钱,吐出:" + money);
                this.money -= money;
                System.out.println(name + "取钱后,剩余:" + this.money);
            } else {
                System.out.println(name + "无法取钱,余额不足");
            }
        } finally {
            lock.unlock();
        }
    }

四、线程通信

1.什么是线程通信

所谓线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

2.线程通信常见形式

通过共享一个数据的方式实现。

根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

3.线程通信实际应用场景

生产者与消费者模型：生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。

要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

4.Object类的等待和唤醒方式

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

注意：上述方法应该使用当前同步锁对象进行调用。

五、线程池

线程池就是一个可以复用线程的技术。

如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

JDK 5.0起提供了代表线程池的接口：ExecutorService

1.如何得到线程池对象

（1）方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

（2）方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

2.ThreadPoolExecutor构造器的参数说明

public ThreadPoolExecutor(

int corePoolSize, --------------->> 指定线程池的线程数量（核心线程）

int maximumPoolSize, --------------->> 指定线程池可支持的最大线程数

long keepAliveTime, --------------->> 指定临时线程的最大存活时间

imeUnit unit, --------------->> 指定存活时间的单位(秒、分、时、天)

BlockingQueue<Runnable> workQueue, --------------->> 指定任务队列

ThreadFactory threadFactory, --------------->> 指定用哪个线程工厂创建线程

RejectedExecutionHandler handler ------------->> 指定线程忙，任务满的时候，新任务来了怎么办

)

示例：

ExecutorService pools = new ThreadPoolExecutor(3 , 5 , 8 , TimeUnit.SECONDS,

new ArrayBlockingQueue<>(6), Executors.defaultThreadFactory() ,

new ThreadPoolExecutor.AbortPolicy());

3.临时线程什么时候创建

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

4.什么时候会开始拒绝任务？

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

5.ExecutorService的常用方法

方法名称	说明
void execute(Runnable command)	执行任务/命令，没有返回值，一般用来执行 Runnable 任务
Future<T> submit(Callable<T> task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行 Callable 任务
void shutdown()	等任务执行完毕后关闭线程池
List<Runnable> shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

6.新任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy：	丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run()方法从而绕过线程池直接执行

7.Executors工具类实现线程池

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。

方法名称	说明
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor ()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

8.Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。不适合做大型互联网场景的线程池方案。

方法名称	存在问题
public static ExecutorService newFixedThreadPool(int nThreads)	允许请求的任务队列长度是Integer.MAX_VALUE，可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newCachedThreadPool()	创建的线程数量最大上限是Integer.MAX_VALUE，线程数可能会随着任务1:1增长，也可能出现OOM错误（ java.lang.OutOfMemoryError ）
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

六、补充知识：定时器

1.定时器概述

定时器是一种控制任务延时调用，或者周期调用的技术。

作用：闹钟、定时邮件发送。

2.定时器的实现方式

（1）方式一：Timer

方法	说明
public void schedule(TimerTask task, long delay, long period)	开启一个定时器，按照计划处理TimerTask任务

Timer定时器的特点和存在的问题

Timer是单线程，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。

可能因为其中的某个任务的异常使Timer线程死掉，从而影响后续任务执行。

package d9_timer;

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

public class TimerDemo1 {
    public static void main(String[] args) {
        //1.创建Timer定时器
        Timer timer = new Timer();//定时器本身就是一个单线程
        //2.调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行AAA一次" + new Date());
                try {
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行BB一次" + new Date());
            }
        }, 0, 2000);
    }
}

（2）方式二：ScheduledExecutorService

ScheduledExecutorService内部为线程池。

Executors的方法	说明
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	得到线程池对象

ScheduledExecutorService的方法

说明

public ScheduledFuture

<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period,TimeUnit unit)

周期调度方法

优点：基于线程池，某个任务的执行情况不会影响其他定时任务的执行。

    public static void main(String[] args) {
        ScheduledExecutorService pool = new ScheduledThreadPoolExecutor(3);
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出AAA  " + new Date());
                try {
                    Thread.sleep(10000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, 0, 2, TimeUnit.SECONDS);
    }