java线程的创建

线程的状态

• NEW: 线程创建之后，但是还没有启动(not yet started)。这时候它的状态就是NEW

• RUNNABLE: 正在Java虚拟机下跑任务的线程的状态。在RUNNABLE状态下的线程可能会处于等待状态， 因为它正在等待一些系统资源的释放，比如IO

• BLOCKED: 阻塞状态，等待锁的释放，比如线程A进入了一个synchronized方法，线程B也想进入这个方法，但是这个方法的锁已经被线程A获取了，这个时候线程B就处于BLOCKED状态

• WAITING: 等待状态，处于等待状态的线程是由于执行了3个方法中的任意方法。 1. Object的wait方法，并且没有使用timeout参数; 2. Thread的join方法，没有使用timeout参数 3. LockSupport的park方法。 处于waiting状态的线程会等待另外一个线程处理特殊的行为。 再举个例子，如果一个线程调用了一个对象的wait方法，那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态

• TIMED_WAITING: 有等待时间的等待状态，比如调用了以下几个方法中的任意方法，并且指定了等待时间，线程就会处于这个状态。 1. Thread.sleep方法 2. Object的wait方法，带有时间 3. Thread.join方法，带有时间 4. LockSupport的parkNanos方法，带有时间 5. LockSupport的parkUntil方法，带有时间

• TERMINATED: 线程中止的状态，这个线程已经完整地执行了它的任务

创建一个线程

Java 提供了三种创建线程的方法：

• 通过实现 Runnable 接口；

• 通过继承 Thread 类本身；

• 通过 Callable 和 Future 创建线程。

Runnable

• 线程代码

public class RunnableDemo implements  Runnable {    private Thread t;    private String threadName;

    RunnableDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }    public void run() {
        System.out.println("Running " +  threadName );        try {            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);// 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }    public void start () {
        System.out.println("Starting " +  threadName );        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

• 测试代码

public class App {
    public static void main(String[] args) {
        RunnableDemo R1 = new RunnableDemo( "Thread-1");
        R1.start();

        RunnableDemo R2 = new RunnableDemo( "Thread-2");
        R2.start();
    }
}

Thread

• 线程代码

public class ThreadDemo extends Thread {    private Thread t;    private String threadName;

    ThreadDemo( String name) {
        threadName = name;
        System.out.println("Creating " +  threadName );
    }    public void run() {
        System.out.println("Running " +  threadName );        try {            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + threadName + ", " + i);// 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  threadName + " interrupted.");
        }
        System.out.println("Thread " +  threadName + " exiting.");
    }    public void start () {
        System.out.println("Starting " +  threadName );        if (t == null) {
            t = new Thread (this, threadName);
            t.start ();
        }
    }
}

• 测试代码

public class App {
    public static void main(String args[]) {
        ThreadDemo T1 = new ThreadDemo( "Thread-1");
        T1.start();

        ThreadDemo T2 = new ThreadDemo( "Thread-2");
        T2.start();
    }
}

Callable 和 Future 创建线程

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

• 线程代码

public class CallableThreadTest implements Callable<Integer> {    @Override
    public Integer call() throws Exception    {        int i = 0;        for(;i<100;i++)
        {
            System.out.println("子线程:"+Thread.currentThread().getName()+" "+i);
        }        return i;
    }
}

• 测试代码

public class App {
    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);        for(int i = 0;i < 100;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);            if(i==20)
            {                new Thread(ft,"有返回值的线程").start();
            }
        }        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }

    }
}

注：低版本的java不支持，maven中指定1.8可以在pom中加如下语句。

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

创建线程的三种方式的对比

• 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。

• 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

线程的几个主要概念

在多线程编程时，你需要了解以下几个概念：

线程同步
线程间通信
线程死锁
线程控制：挂起、停止和恢复