Java多线程编程学习——01线程的创建方式和生命周期

什么是并发与并行？

并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。

什么是进程、线程?

1. 进程是系统中正在运行的一个程序，程序一旦运行就是进程。

2. 进程可以看成程序执行的一个实例。进程是系统资源分配的独立实体，每个进程都拥有独立的地址空间。一个进程无法访问另一个进程的变量和数据结构，如果想让一个进程访问另一个进程的资源，需要使用进程间通信，比如管道，文件，套接字等。

3. 一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。线程与进程的一个主要区别是，统一进程内的一个主要区别是，同一进程内的多个线程会共享部分状态，多个线程可以读写同一块内存（一个进程无法直接访问另一进程的内存）。同时，每个线程还拥有自己的寄存器和栈，其他线程可以读写这些栈内存。

4. 线程是进程的一个实体，是进程的一条执行路径。

5. 线程是进程的一个特定执行路径。当一个线程修改了进程的资源，它的兄弟线程可以立即看到这种变化。
   
   

线程的创建

Java中线程有四种创建方式：

• 继承Thread类

public class MyThread01 extends Thread {

    int num = 0;

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synchronized (MyThread01.class) {
                System.out.println("订单号 : " + num++);
            }
        }
    }

    public static void main(String[] args) {
        MyThread01 myThread01 = new MyThread01();
        MyThread01 myThread02 = new MyThread01();
        myThread01.start();
        myThread02.start();

    }
}

• 实现Runnable接口

public class MyThread02 implements Runnable {

    int num = 0;

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
                System.out.println("订单号 : " + num++);
        }
    }

    public static void main(String[] args) {

        Thread thread01 = new Thread(new MyThread02());
        Thread thread02 = new Thread(new MyThread02());
        thread01.start();
        thread02.start();

    }
}

• 实现Callable接口

public class MyThread03 implements Callable {
    static int num = 0;

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 20; i++) {
            synchronized (MyThread02.class) {
                System.out.println("订单号 : " + num++);
            }
        }
        return "MyThread执行完毕";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task01 = new FutureTask(new MyThread03());
        FutureTask task02 = new FutureTask(new MyThread03());
        Thread thread01 = new Thread(task01);
        Thread thread02 = new Thread(task02);
        thread01.start();
        thread02.start();
        System.out.println("thread01： "+task01.get());
        System.out.println("thread02： "+task02.get());
    }
}

• 线程池

  public class MyThread04 implements Runnable {

     int num = 0;

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synchronized (MyThread04.class) {
                System.out.println(Thread.currentThread().getName()+" 的订单号 : " + num++);
            }
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new MyThread04());
        executorService.execute(new MyThread04());
        executorService.execute(new MyThread04());

    }
}

什么是FutureTask?

  FutureTask 表示一个异步运算的任务。FutureTask 里面可以传入一个 Callable 的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。只有当运算完成的时候结果才能取回，如果运算尚未完成 get 方法将会阻塞直到获得预知的结果。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装，由于 FutureTask 也是Runnable 接口的实现类，所以 FutureTask 也可以放入线程池中。

Future接口：

判断任务是否完成：isDone()
能够中断任务：cancel()
能够获取任务执行结果：get()

实现接口和继承Thread类比较

• 接口更适合多个相同的程序代码的线程去共享同一个资源。
• 接口可以避免java中的单继承的局限性。
• 接口代码可以被多个线程共享，代码和线程独立。
• 线程池只能放入实现Runable或Callable接口的线程，不能直接放入继承Thread的类。
  
  

Runnable和Callable接口比较

相同点：

两者都是接口；
两者都可用来编写多线程程序；
两者都需要调用Thread.start()启动线程；

不同点：

实现Callable接口的线程能返回执行结果；而实现Runnable接口的线程不能返回结果；
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的不允许抛异常；
实现Callable接口的线程可以调用Future.cancel取消执行 ，而实现Runnable接口的线程不能

注意点：

Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

线程生命周期

新建

new关键字创建了一个线程之后，该线程就处于新建状态
JVM为线程分配内存，初始化成员变量值

就绪

1. 当线程对象调用了start()方法之后，该线程处于就绪状态

2. JVM为线程创建方法栈和程序计数器，等待线程调度器调度

运行

就绪状态的线程获得CPU资源，开始运行run()方法，该线程进入运行状态

阻塞

当发生如下情况时，线程将会进入阻塞状态

1. 线程调用sleep()方法主动放弃所占用的处理器资源
2. 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞
3. 线程试图获得一个同步锁（同步监视器），但该同步锁正被其他线程所持有。
4. 线程在等待某个通知（notify） 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法

死亡

线程会以如下3种方式结束，结束后就处于死亡状态：

1. run()或call()方法执行完成，线程正常结束。
2. 线程抛出一个未捕获的Exception或Error。
3. 调用该线程stop()方法来结束该线程，该方法容易导致死锁，不推荐使用。