碎碎念③线程实现

概念

进程就是一个应用程序；

线程就是一个进程中的执行单元；

而一个进程能启动多个线程；

各个进程是独立的，同一进程中的线程极有可能会互相影响；

线程基本状态

NEW          初始状态

RUNNABLE 运行状态

BLOCKED 阻塞状态

WAITING 等待状态

TIME_WAITING 超时等待状态

TERMINATED 终止状态

线程实现方式

1、编写一个类，继承Thread类，重写run()方法：

// 定义线程类
public class MyThread extends Thread{
	public void run(){
	
	}
}
// 创建线程对象
MyThread t = new MyThread();
// 启动线程。
t.start();

2、编写一个类，实现Runnable接口，实现run方法：

// 定义一个可运行的类
public class MyRunnable implements Runnable {
	public void run(){
	
	}
}
// 创建线程对象
Thread t = new Thread(new MyRunnable());
// 启动线程
t.start();

3、实现Callable接口，实现call()方法：

//可以获取线程的返回值，但是效率比较低，在获取线程执行结果时候，当前线程受阻塞

public class ThreadTest15 {
    public static void main(String[] args) throws Exception {

        // 创建一个“未来任务类”对象。
            FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值

                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱(300结果变成Integer)
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);

        // 启动线程
        t.start();

        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);

        System.out.println("hello world!");
    }
}

4、通过Executor的工具类创建线程池，通过线程池获取线程

import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings("unchecked")
public class Test {
    public static void main(String[] args) throws ExecutionException,
            InterruptedException {
        System.out.println("----程序开始运行----");
        Date date1 = new Date();

        int taskSize = 5;
        // 创建一个线程池  
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);
        // 创建多个有返回值的任务  
        List<Future> list = new ArrayList<Future>();
        for (int i = 0; i < taskSize; i++) {
            Callable c = new MyCallable(i + " ");
            // 执行任务并获取Future对象  
            Future f = pool.submit(c);
            // System.out.println(">>>" + f.get().toString());  
            list.add(f);
        }
        // 关闭线程池  
        pool.shutdown();

        // 获取所有并发任务的运行结果  
        for (Future f : list) {
            // 从Future对象上获取任务的返回值，并输出到控制台  
            System.out.println(">>>" + f.get().toString());
        }

        Date date2 = new Date();
        System.out.println("----程序结束运行----，程序运行时间【"
                + (date2.getTime() - date1.getTime()) + "毫秒】");
    }
}

class MyCallable implements Callable<Object> {
    private String taskNum;

    MyCallable(String taskNum) {
        this.taskNum = taskNum;
    }

    public Object call() throws Exception {
        System.out.println(">>>" + taskNum + "任务启动");
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum + "任务终止");
        return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
    }
}

注意

1 获取当前线程的对象的方法是：Thread.currentThread()；

2 当线程目标 run() 方法结束时该线程完成。

3 一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

4 线程的调度是 JVM 的一部分，在一个 CPU 的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM 线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

5 尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成 “一轮” 时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列一个队列的事实。

6 尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

7t.run() 不会启动线程，只是普通的调用方法而已。不会分配新的分支栈。（这种方式就是单线程。）

t.start() 方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。