java之多线程(一)——线程的创建以及常用API

概念

什么是程序？

程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

什么是进程？

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在、消亡的过程。——生命周期
1、进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
2、程序时静态的，进程时动态的。

什么是线程？

进程可进一步细化为线程，是一个程序内部的一条执行路径。
1、若一个进程同一时间并行执行多个线程，就是支持多线程的。
2、线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。
3、一个进程中多个线程共享相同内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能会带来安全隐患。

并行与并发

并行：多个cpu同时执行多个任务。
并发：一个cpu(采用时间片)同时执行多个任务。

多线程的优点

1、提高应用程序的相应，对图形化界面更有意义，可增强用户的体验。
2、提高计算机系统cpu的利用率
3、改善程序结构。将复杂的进程分为多个线程，独立运行，利于理解和修改。

何时使用多线程

1、程序需要同时执行两个或多个任务。
2、程序需要实现一些需要等待的任务，如用户输入，文件读写，搜索等。
3、需要一些后台运行的程序时。

线程APi（Thread类的相关方法）

void start()	启动线程，并执行对象的run()方法
run()	线程在被调度时执行的操作
String getName()	返回线程的名称
void setName(String name)	设置该线程的名称
static Thread currentThread()	返回当前线程。在Thread子类中就时this，通常用于主线程和Runnable实现类
static void yield()	线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或者更高的线程，若队列中没有同优先级的线程，忽略此方法
join()	当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，知道join()方法加入的join线程执行完为止，低优先级的线程也可以获得执行
static void sleep(long millis)	令当前活动线程在指定时间段内放弃对CPU控制，使其它线程有机会被执行，时间到后重排队，需要抛出异常
stop()	强制线程生命周期结束，不推荐使用
boolean isAlive()	判断线程是否还存活

线程的优先级

线程的调度策略：1、时间片 2、抢占式：高优先级线程抢占CPU

线程的优先级等级：

1、MAX_PRIORITY:10
2、MIN_PRIORITY:1
3、NORM_PRIORITY:5

API

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

说明

1、线程创建时继承父线程的优先级。
2、低优先级知识获得调度的概率低，并非一定是在高优先级线程之后才被调用。

创建线程的方式

创建线程有四种方式
1、继承Thread类重写run()。
2、实现Runnable接口重写run()。
3、实现Callable接口重写call()。
4、使用线程池创建。

方式一：继承Thread类

1、创建一个继承于Thread类的子类
2、重写Thread类的run()
3、创建Thread类的子类的对象
4、通过此对象调用start()

//1、创建一个继承于Thread类的子类
class Mythread extends Thread{
    @Override
    //2、重写Thread类的run()
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3、创建Thread类的子类对象
        Mythread t1 = new Mythread();
        //4、通过此对象调用start()，① 启动当前线程  ② 调用run()
        t1.start();
        //如果需要再此启动一个线程，需要重新创建一个线程对象
        Mythread t2 = new Mythread();
        t2.start();
    }
}

还可以以匿名子类的方式创建线程，只能使用一次

//以匿名子类的方式创建线程，只能使用一次
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if (i % 2 != 0){
                        System.out.println(i+"  ");
                    }
                }
            }
        }.start();

方式二：实现Runnable接口

1、创建一个实现Runnable接口的类
2、实现类去实现Runnable中的抽象方法：run()
3、创建实现类的对象
4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5、通过Thread类的对象调用start()

//1、创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //2、实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3、创建实现类的对象
        MThread mThread = new MThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread对象
        Thread t1 = new Thread(mThread);
        //5、通过Thread类的对象调用start()，->调用了Runnable类型的target
        t1.start();
        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

继承Thread和实现Runnable两种方式对比

在开法中：优先选择：实现Runnable接口的方式
原因：
1、实现的方式没有类的单继承的局限性。
2、实现的方式更适合来处理多个线程有共享的数据情况。

方式三：实现Callable接口。——JDK 5.0新增

1、创建一个实现Callable的实现类。
2、实现call方法，将此线程需要执行的操作声明再call()中。
3、创建Callable接口实现类对象。
4、将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象。
5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()。

//1、创建一个实现Callable的实现类
class NumThread implements Callable{

    @Override
    //2、实现call方法，将此线程需要执行的操作声明再call()中
    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 ThreadCallTest {
    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()
        //在底层源码中，FutureTask间接实现了Runnable()
        new Thread(futureTask).start();
        try {
            //get()返回值为FutureTask构造器参数Callable实现类重写的Call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

实现Callable接口创建多线程比实现Runnable接口创建线程方式强大的原因：

1、call()可以有返回值。
2、call()可以抛出异常，被外面的操作捕获，获取异常信息。
3、Callable支持泛型。

Future接口

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

方式四：线程池 ——jdk5.0新增

1、提供指定数量的线程池
2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
3、关闭线程池

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 ==0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1、提供指定数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        //service.submit()使用于Callable


        //3、关闭线程池
        service.shutdown();

    }
}

线程池相关API

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

API
void execute(Runnable command)	执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)	执行任务，有返回值，一般又来执行Callable
void shutdown()	关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池
–	–
Executors.newCachedThreadPool()	创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n)	创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()	创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)	创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行

使用线程池的好处

1、提高相应速度(减少了创建新线程的时间)。
2、降低资源消耗(重复利用线程池中线程，不需要每次都创建)。
3、便于线程管理

corePoolSize: 核心池的大小
maximumPoolSize: 最大线程数
keepAliveTime: 线程没有任务时最多保持多长时间后会终止