Java多线程 --Thread-阿里云开发者社区

多线程

概念：多线程是指从软硬件上实现多条执行流程的技术

多线程的创建

方式一：继承Tread类

Java是通过java.lang.Thread类来代表线程的。

实现步骤：

创建继承Thread类

重写run类

创建线程对象

调用start()方法启动

优缺点：

优点：编码简单

缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，(单一继承)，不便于扩展。不能返回结果

/*
目标：多线程的创建方式一
1. 创建继承Thread类
2. 重写run类
3. 创建线程对象
4. 调用start()方法启动
每次执行的子主线程顺序不一样
但是主线程的主要执行的 必须要在start启动之后
不然就是一个单线程  不能实现多线程的功能
*/
public class ThreadDemo01 {
    public static void main(String[] args) {
        //3.new一个新线程
        Thread ts = new MyThread();
        //4。调用start方法、启动线程
        ts.start();
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行" + i);
        }
    }
}
/*
 * 1.创建MyThread类继承Thread类
 * */
class MyThread extends Thread {
     //2.重写run()方法   里面是定义线程
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行" + i);
        }
    }
}

方式二：实现Runnable接口

第一种方式步骤

定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
创建MyRunnable任务对象
把MyRunnable任务对象交给Thread处理。
调用线程对象的start()方法启动线程

优缺点

优点:线程任务类只是实现了Runnale接口，可以继续继承和实现。
缺点:如果线程有执行结果是不能直接返回的。

public class ThreadDemo02 {
    public static void main(String[] args) {
        //3.创建MyRunnable对象
        Runnable target = new MyRunnable();//多态写法
        //4.把MyRunnable任务对象交给Thread处理。
        Thread t = new Thread(target);
        //5.start()方法启动线程
        t.start();
        //主线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行！！" + i);
        }
    }
}
//1.定义MyRunnable实现 Runnable接口
class MyRunnable implements Runnable {
    //2.重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}

第二种方式步骤：

实现Runnable接口（匿名内部类形式
可以创建Runnable的匿名内部类对象。
交给Thread处理。
调用线程对象的start()启动线程。

/*
- 实现Runnable接口（匿名内部类形式)
- 可以创建Runnable的匿名内部类对象。
- 交给Thread处理。
- 调用线程对象的start()启动线程。
*/
public class ThreadDemo02Other {
    public static void main(String[] args) {
        //第一个子线程
        //创建MyRunnable对象
        Runnable target = new Runnable(){
            //2.重写run()方法
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程1执行输出" + i);
                }
            }
        };
        //把MyRunnable任务对象交给Thread处理。
        Thread t = new Thread(target);
        //start()方法启动线程
        t.start();
        //第二个子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程2执行输出" + i);
                }
            }
        }).start();
        //第三个子线程
        new Thread(()-> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程3执行输出" + i);
                }
        }).start();
        //主线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

方式三:JDK5.0新增实现Callable接口

优点是：能得到返回结果

利用Callable、FutureTask接实现。得到任务对象

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

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

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

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

线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。优缺点：

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

public class ThreadDemo03 {
    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> call1 = new MyCallable(10);
        FutureTask<String> f2 = new FutureTask<>(call1);
        Thread t2 = new Thread(f2);
        t2.start();
        //7.get方法获取任务执行的结果
        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String s1 = f1.get();
            System.out.println("线程1获取到的结果"+s1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            //如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String s2 = f2.get();
            System.out.println("线程1获取到的结果"+s2);
        } 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 = 0; i <= n; i++) {
            sum += i;
        }
        return "子线程执行的结果是：" + sum;
    }
}

Thread类的常用方法

方法	说明
getName()	获取线程名称
setName()	设置名称
currentThread()	获取当前线程对象
构造器	说明

public Thread(String name)	可以为当前线程指定名称（一般不用设置）
public Thread(Runnable target)	可以为当前线程指定名称

public Thread(ThreadGroup group, Runnable target)

封装Runnable对象成为线程对象，并指定线程名称

public static void sleep(long millis)

使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）结束后继续执行

public class ThreadApiDemo04 {
    public static void main(String[] args) {
        //创建Thread对象
        Thread t1 = new MyThread("1号线程");
        //启动线程
        t1.start();
        //设置线程的名称
//        t1.setName("1号线程");
        //当前线程的名称
        System.out.println("t1线程的名称：" + t1.getName());
        Thread t2 = new MyThread("2号线程");
        t2.start();
//        t2.setName("2号线程");
        System.out.println("t2线程名称：" + t2.getName());
        //哪个线程执行它 就得到哪个线程的名称（当前线程对象）
        //主线程名称就是main
        Thread n = Thread.currentThread();
        System.out.println(n.getName());
        //修改主线程名字
        n.setName("最牛的线程。");
        for (int i = 0; i < 5; i++) {
            System.out.println(n.getName() + "输出" + i);
        }
    }
}
class MyThread extends Thread {
    public MyThread() {
    }
    public MyThread(String name) {
        //为当前对象设置名称 送给父类的有参构造方法构造器初始化名称
        //就不用setName的设置名称
        super(name);
    }
    //重写run()
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);//哪个线程执行它 就得到哪个线程的名称（当前线程对象）
        }
    }
}

Thread线程的休眠方法：public static void sleep(long millis)

  for (int i = 0; i < 5; i++) {
            System.out.println(n.getName() + "输出" + i);
            if (i == 3){
                //让线程休息一会
                //交钱就走快一点
                Thread.sleep(3000);//3s
            }
        }

线程安全

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

出现原因

存在多线程并发
同时访问共享资源
存在修改共享资源

案例解释

/*
* 取钱业务
*   需求:
         小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟2人同时去取钱10万。
    分析:
        ①:需要提供一个账户类，创建一个账户对象代表2个人的共享账户。
        ②:需要定义一个线程类，线程类可以处理账户对象。
        ③:创建2个线程对象，传入同一个账户对象。
        ④:启动2个线程，去同一个账户对象中取钱10万。
* */
//主线程
public class ThreadSafetyTest {
    public static void main(String[] args) {
        //1.定义一个线程类 创建一个共享的账户对象
        Account acc = new Account("ICBC-1", 100000);
        //2.创建2个线程对象,代表小明和小红
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();
    }
}
//账户类
public class Account {
    private String cardId;//卡号
    private double money;//账户余额
    public Account() {
    }
    //有参构造器
    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }
    //  小明和 小红取钱
    public void drawMoney(double money) {
        //1.先判断谁来取钱  线程名字的人名
        String name = Thread.currentThread().getName();
        //2.判断账户余额是否够钱
        if (this.money >= money) {
            //先取钱再更新余额
            //3.取钱
            System.out.println(name + "来取钱成功 吐出" + money);
            //4.更新余额
            this.money -= money;
            //提示
            System.out.println(name + "来取钱后剩余：" + this.money);
        } else {
            System.out.println(name+"来取钱,但是余额不足！！");
        }
    }
    public String getCardId() {
        return cardId;
    }
    public void setCardId(String cardId) {
        this.cardId = cardId;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
}
/*
* 取钱的线程类  要继承Thread
* */
public class DrawThread extends Thread {
    //接受处理账户的对象
    private Account acc;
    public DrawThread(Account acc,String name) {
        super(name);//必须要在最前面
        this.acc = acc;
    }
    //重写方法
    @Override
    public void run() {
        //小明  小红  取钱
        acc.drawMoney(100000);
    }
}

线程同步（解决线程安全问题）

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

让多个线程实现先后依次访问共享资源

加锁方式

方式一:同步代码块

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

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

对出现问题的核心代码使用synchronized进行加锁

每次只能一个线程占锁进入访问

要求：锁对象只要对于当前同时执行的线程来说是同一个对象即可。不能用任意唯一的锁作为锁

synchronized(同步锁对象){
  核心共享资源的代码（核心代码）
}
上面存在安全问题的代码
    //同步代码块
        //锁名称要唯一
        synchronized ("kcs") {
            //2.判断账户余额是否够钱  (以下存在安全问题)
            if (this.money >= money) {
                //先取钱再更新余额
                //3.取钱
                System.out.println(name + "来取钱成功 吐出" + money);
                //4.更新余额
                this.money -= money;
                //提示
                System.out.println(name + "来取钱后剩余：" + this.money);
            } else {
                System.out.println(name+"来取钱,但是余额不足！！");
            }
        }

锁对象的规范要求：

建议使用共享资源作为锁对象

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

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

方式二：同步方法

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

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

public synchronized void drawMoney(double money)

同步方法底层原理

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

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

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

方式三：Lock锁

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

方法	说明
lock	获得锁
unLock	解锁

try - catch - finally

// final修饰后:锁对象是唯一和不可替换的，非常专业
private final Lock lock = new ReentrantLock();
public  void drawMoney(double money) {
        //1.先判断谁来取钱  线程名字的人名
        String name = Thread.currentThread().getName();
        Lock.Lock();//上锁
            //2.判断账户余额是否够钱  (以下存在安全问题)
      try{
                if (this.money >= money) {
                    //先取钱再更新余额
                    //3.取钱
                    System.out.println(name + "来取钱成功 吐出" + money);
                    //4.更新余额
                    this.money -= money;
                    //提示
                    System.out.println(name + "来取钱后剩余：" + this.money);
                } else {
                    System.out.println(name+"来取钱,但是余额不足！！");
                }finally{
                   lock.unLock();解锁 
                }
        }    
    }

线程通信

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

常见形式

通过共享一个数据的方式实现。
根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做

应用场景

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

常用方法

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

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

线程池（重点）

复用线程的技术

问题

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

线程池实现的API、参数说明

线程池接口：ExecutorService

创建线程池对象：

方式一：实现类 ThreadPoolExecutor自创建一个线程池对象 (重点)

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

参数一:指定线程池的线程数量（核心线程): corePoolSize 不能小于0

参数二:指定线程池可支持的最大线程数: maximumPoolSize 最大数量>=核心线程数量

参数三:指定临时线程的最大存活时间: keepAliveTime 不能小于0

参数四:指定存活时间的单位(秒、分、时、天): unit 时间单位

参数五:指定任务队列:workQueue 不能为null

参数六:指定用哪个线程工厂创建线程: threadFactory 不能为null

参数七:指定线程忙，任务满的时候，新任务来了怎么办: handler 不能为null

临时线程什么时候创建

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

什么时候会开始拒绝任务

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

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

线程池处理Runnable任务

void execute(Runnable command)

/*
 * 自定义一个线程池 ,并测试其特性
 * */
public class ThreadPoolDemo01 {
    public static void main(String[] args) {
        /*
        * public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
                              * */
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        //2.给任务线程池处理[
        MyRunnables mr = new MyRunnables();
        pool.execute(mr);
        pool.execute(mr);
        pool.execute(mr);
        //线程复用 已经超出了线程池的大小
        pool.execute(mr);
        pool.execute(mr);
        //停止线程  开发中一般不使用
        pool.shutdownNow();//立即关闭 即使任务没有完成
        pool.shutdown();//任务跑完才关闭  因为在sleep不能关闭
    }
}
class MyRunnables implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了==》" + i);
        }
        //睡眠
        try {
            System.out.println(Thread.currentThread().getName() + "本线程已绑定，线程任务进入休眠状态~~~");
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程池处理Callable任务

Future<T> submit(callable<T> task) 执行callable任务，返回未来任务对象获取线程结果

public class ThreadPoolDemo02 {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        //给任务线程池处理
        Future<String> s1 = pool.submit(new MyCallable(50));
        Future<String> s2 = pool.submit(new MyCallable(150));
        Future<String> s3 = pool.submit(new MyCallable(250));
        Future<String> s4 = pool.submit(new MyCallable(350));
        Future<String> s5 = pool.submit(new MyCallable(450));
//        String s = s1.get();
//        System.out.println(s);
        System.out.println(s1.get());
        System.out.println(s2.get());
        System.out.println(s3.get());
        System.out.println(s4.get());
        System.out.println(s5.get());
    }
}
class MyCallable implements Callable<String> {
    //定义一个变量
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        //求和
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()+"执行1-"+n+"的和的结果是："+ sum;
    }
}

Executors工具类实现线程池

方法名称	说明
public static ExecutorService newCachedThreadPoo1()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了一段时间则会被回收掉。

public static ExecutorService newFixedThreadPool(int nThreads)

创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。

public static ExecutorService newSingleThreadExecutor ()

创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。

public static scheduledExecutorService newScheduledThreadPool(int corePoolSize)

创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

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

Executors不适合做大型互联网场景的线程池方案

建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则规避资源耗尽的风险。

/*
* Executors工具方法直接得到一个线程池对象
* */
public class ExecutorsDemo01 {
    public static void main(String[] args) {
        //创建固定线程池对象
        ExecutorService pools = Executors.newFixedThreadPool(3);
        pools.execute(new MyRunnables());
        pools.execute(new MyRunnables());
        pools.execute(new MyRunnables());
        //超出线程  没有多余线程
        pools.execute(new MyRunnables());
        pools.execute(new MyRunnables());
    }
}
public class MyRunnables {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了==》" + i);
        }
        //睡眠
        try {
            System.out.println(Thread.currentThread().getName() + "本线程已绑定，线程任务进入休眠状态~~~");
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

定时器(Timer)

schedule(TimerTask task, long delay, long period) 在指定 的延迟之后开始 ，重新执行 固定延迟执行的指定任务

/*
*
* 目标： 定时器的使用和了解
* */
public class TimerDemo01 {
    public static void main(String[] args) {
        //1.创建Timer定时器
        Timer t = new Timer();  //单线程
        //2.调用定时器 处理任务  匿名内部类
        t.schedule(new TimerTask() { 
            @Override
            public void run() {
                System.out.println("执行一次~~");
            }
        },3000,2000);   //delay 是3秒后才启动  period是每两秒执行一次
    }
}

ScheduledExecutorService的优点

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

/*
 * 基于线程池，某个任务的执行情况不会影响其他定时任务的执行。
 * */
public class TimerDemo02 {
    public static void main(String[] args) {
        //1.创建ScheduledExecutorService线程池 做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3); //定时线程池的大小
        //2.开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出AAA==>" + new Date());
                //A任务进行睡眠
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 1, TimeUnit.SECONDS);// TimeUnit unit 是 时间的单位
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出BBB==>" + new Date());
                System.out.println(10 / 0);//存在异常
            }
        }, 0, 1, TimeUnit.SECONDS);// TimeUnit unit 是 时间的单位
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出CCC==>" + new Date());
            }
        }, 0, 1, TimeUnit.SECONDS);// TimeUnit unit 是 时间的单位  间隔两秒
    }
}

线程状态等

正在运行的程序（软件）就是一个独立的进程，线程是属于进程的，多个线程其实是并发与并行同时进行的。

线程的状态:也就是线程从生到死的过程，以及中间经历的各种状态及状态转换。
理解线程的状态有利于提升并发编程的理解能力。

Java线程的状态

Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。

public enum State {
     NEW,  //新建        线程刚被创建，但是并未启动。
    RUNNABLE,//可运行      线程已经调用了start()等待CPU调度
    BLOCKED, //锁阻塞      线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态；。
    WAITING,//无线等待       一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒  
    TIMED_WAITING,//计时等待  同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。带有超时参数的常用方法有Thread.sleep、Object.wait。
    TERMINATED;//被终止    因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
}

并法、并行

CPU同时处理线程的数量有限。
CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并发:CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。

Java多线程 --Thread

多线程

多线程的创建

方式一：继承Tread类

方式二：实现Runnable接口

方式三:JDK5.0新增实现Callable接口

Thread类的常用方法

线程安全

出现原因

线程同步（解决线程安全问题）

加锁方式

线程通信

应用场景

线程池（重点）

问题

线程池实现的API、参数说明

创建线程池对象：

临时线程什么时候创建

什么时候会开始拒绝任务

线程池处理Runnable任务

线程池处理Callable任务

Executors工具类实现线程池

定时器(Timer)

线程状态等

Java线程的状态

并法、并行

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java多线程 --Thread

多线程

多线程的创建

方式一：继承Tread类

方式二：实现Runnable接口

方式三:JDK5.0新增 实现Callable接口

Thread类的常用方法

线程安全

出现原因

线程同步（解决线程安全问题）

加锁方式

线程通信

应用场景

线程池（重点）

问题

线程池实现的API、参数说明

创建线程池对象：

临时线程什么时候创建

什么时候会开始拒绝任务

线程池处理Runnable任务

线程池处理Callable任务

Executors工具类实现线程池

定时器(Timer)

线程状态等

Java线程的状态

并法、并行

热门文章

最新文章

相关课程

相关电子书

相关实验场景

方式三:JDK5.0新增实现Callable接口