java从基础知识（十）java多线程（上）

　　线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

　　这一节介绍线程的启动方式及Thread类。

一、线程的启动方式

1、通过Thread类启动

public class ThreadTest extends Thread {

    private String name;

    public ThreadTest(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++)
        System.out.println(name + " thread : " + i);
    }

    public static void main(String[] args) {
        ThreadTest tt1 = new ThreadTest("tt1");
        tt1.start();//使该线程开始执行；Java 虚拟机调用该线程的 run 方法
        ThreadTest tt2 = new ThreadTest("tt2");
        tt2.start();
    }
}

　　注意：线程是通过start的方法启动的，run方法是用来实现逻辑的。

2、通过Runnable接口启动

public class RunnableTest implements Runnable {

    private String name;

    public RunnableTest(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(name + " runnabel : " + i);
        }
    }

    public static void main(String[] args) {
        RunnableTest rt1 = new RunnableTest("rt1");
        Thread t1 = new Thread(rt1);
        t1.start();
        RunnableTest rt2 = new RunnableTest("rt2");
        Thread t2 = new Thread(rt2);
        t2.start();
    }
}

3、使用ExecutorService、Callable、Future实现有返回结果的多线程

public class ExcuteTest {

    public static void main(String[] args) {
        System.out.println("----程序开始运行----");

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

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

    }
}

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

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

    public Object call() {
        for (int i = 0; i < 100; i++) {
            System.out.println(name + " : " + i);
        }
        return name + " end";
    }

}

二、Thread介绍

public class ThreadTest extends Thread {

    private String name;

    public ThreadTest(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("返回当前线程的线程组中活动线程的数目 " + name + " : " + Thread.activeCount());
        System.out.println("返回对当前正在执行的线程对象的引用 " + name + " : " + Thread.currentThread());
        try {
            for (int i = 0; i < 100; i++) {
                Thread.currentThread().sleep(1);
                System.out.println(name + " thread : " + i);
                //Thread.currentThread().interrupt();//中断线程
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ThreadTest tt1 = new ThreadTest("tt1");
        tt1.setName("t1");//改变线程名称，使之与参数 name 相同
        tt1.start();//使该线程开始执行；Java 虚拟机调用该线程的 run 方法

        System.out.println("返回该线程的标识符 tt1 : " + tt1.getId());
        System.out.println("返回该线程的名称 tt1 : " + tt1.getName());
        System.out.println("返回线程的优先级 tt1 : " + tt1.getPriority());
        System.out.println("返回该线程的状态 tt1 : " + tt1.getState());

        System.out.println("测试线程是否处于活动状态 tt1 : " + tt1.isAlive());
        System.out.println("测试当前线程是否已经中断 tt1 : " + tt1.isInterrupted());
        System.out.println("测试该线程是否为守护线程 tt1 : " + tt1.isDaemon());

        ThreadTest tt2 = new ThreadTest("tt2");
        tt2.setName("t2");
        System.out.println("返回线程的优先级 tt2 : " + tt2.getPriority());
        tt1.yield();//暂停当前正在执行的线程对象，并执行其他线程
        try {
            //tt1.join();//等待该线程终止
            tt1.join(10);//等待该线程终止的时间最长为 millis 毫秒
            //tt1.join(10, 10);//等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tt2.start();
    }
}

三、Thread与Runnable的区别

1、Runnable方式可以避免Tread方式由于java单继承特性带来的缺陷。Runnable的代码可以被多个线程（Thread实例）共享，适合于多个线程处理同一资源的情况。

JAVA多线程实现的三种方式

Java总结篇系列：Java多线程（一）