Java中线程的创建与使用

---

前言

1）Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread
类来体现。
2）Thread类的特性
①每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常
把run()方法的主体称为线程体
②通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

---

一、Thread类

1.构造器

①Thread()：创建新的Thread对象
②Thread(String threadname)：创建线程并指定线程实例名
③Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
④Thread(Runnable target, String name)：创建新的Thread对象

二、API创建线程的两种方式

JDK1.5之前创建新执行线程有两种方法：
1）继承Thread类的方式
2）实现Runnable接口的方式

1.方式一：继承Thread类

1）定义子类继承Thread类。
2）子类中重写Thread类中的run方法。
3）创建Thread子类对象，即创建了线程对象。
4）调用线程对象start方法：启动线程，调用run方法。

【注意】：
① 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
② run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
③ 想要启动多线程，必须调用start方法。
④ 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

2.方式二：实现Runnable接口

1）定义子类，实现Runnable接口。
2）子类中重写Runnable接口中的run方法。
3）通过Thread类含参构造器创建线程对象。
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5）调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

三、JDK5.0新增线程创建方式

1.新增方式一：实现Callable接口

与使用Runnable相比， Callable功能更强大些
1）相比run()方法，可以有返回值
2）方法可以抛出异常
3）支持泛型的返回值
4）需要借助FutureTask类，比如获取返回结果

Future接口：
1）可以对具体Runnable、Callable任务的执行结果进行取消、查询是
否完成、获取结果等。
2）FutrueTask是Futrue接口的唯一的实现类
3）FutureTask 同时实现了Runnable, Future接口。它既可以作为
Runnable被线程执行，又可以作为Future得到Callable的返回值

通过实现Callable接口创建线程方式代码示例：

//1.创建一个实现Callable接口的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask的构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
        new Thread(futureTask).start();

        try {
            //get()返回值为FutureTask构造器参数Callable实现类重写的call()的返回值
            //6.获取Callable中call()的返回值
            Object num = futureTask.get();
            System.out.println("总和为：" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2.新增方式二：使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交
通工具。
好处：
1） 提高响应速度（减少了创建新线程的时间）
2）降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3）便于线程管理
① corePoolSize：核心池的大小
② maximumPoolSize：最大线程数
③ keepAliveTime：线程没有任务时最多保持多长时间后会终止
④ …

线程池相关API：
1）JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
2）ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
① void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
② Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
③ void shutdown() ：关闭连接池
3） Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
① Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
② Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
③ Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
④ Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

利用线程池创建线程代码示例：

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}
class NumberThread2 implements Callable{

    @Override
    public Object call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
        return null;
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10); //ExecutorService是接口，是一种多态的形式
        /**
         * 接口中的属性是常量，不能修改设置，ExecutorService是接口，通过查看当前类的方式得到service的当前类是
         * ThreadPoolExecutor，将service进行强转，得到ThreadPoolExecutor类型的service1，通过
         * service1调用参数进行修改
         */
        ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();
        service1.setMaximumPoolSize(20);

        //设置线程池的属性
//        System.out.println(service.getClass());


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread()); //适用于Runnable
        service.submit(new NumberThread2()); //适用于Callable

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

四、继承方式和实现方式的联系与区别

public class Thread extends Object implements Runnable

1.区别

继承Thread：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。

2.实现方式的好处

避免了单继承的局限性
多个线程可以共享同一个接口实现类的对象，非常适合多个相同线
程来处理同一份资源。

五、Thread类的有关方法

1.常用方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static Thread currentThread(): 返回当前线程。在Thread子类中就
是this，通常用于主线程和Runnable实现类

2.其他方法

static void yield()：线程让步
① 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程（与优先级相同或更高的线程交错执行，因为cpu的分配是随机的）
② 若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将
被阻塞，直到 join() 方法加入的 join 线程执行完为止（其他线程执行完才能继续执行）
① 低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
① 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
② 抛出InterruptedException异常
stop(): 强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着

六、线程的调度

1.调度策略

时间片：

Java的调度方法：
① 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
② 对高优先级，使用优先调度的抢占式策略

2.线程的优先级

线程的优先级等级：
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5

涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

说明：
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

七、线程的调度

Java中的线程分为两类：一种是守护线程，一种是用户线程。
1）它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
2）守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
3）Java垃圾回收就是一个典型的守护线程。
4）若JVM中都是守护线程，当前JVM将退出。
形象理解：兔死狗烹，鸟尽弓藏

---