Java多线程知识汇总（一）

目录

• 一、线程的生命周期
• ?二、Java线程实现方式
• 1、继承Thread类
• 2、实现Runnable接口
• 3、通过Callable和Future创建线程
• 4、三种方式的对比
• 三、线程的几个主要概念

一、线程的生命周期

线程是一个动态执行的过程，一个线程从产生到死亡的过程叫做线程的生命周期。理解线程的生命周期对线程的应用开发有很大的帮助，所以本文把线程完整的生命周期图示放在最前面。

?二、Java线程实现方式

1、继承Thread类

实现步骤：

①、定义类继承Thread；

②、重写Thread类中的run方法，在run方法中实现需要自定义的业务代码；

③、调用线程的start方法：实例化线程后，执行run方法。

?代码示例：

public class ThreadTest {
    class MyThread extends Thread { //自定义一个线程类
        private int i = 0;

        @Override
        public void run() { //重写线程执行方法
            for (i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread myThread1 = new MyThread(); // 创建一个新的线程  myThread1  此线程进入新建状态
                Thread myThread2 = new MyThread(); // 创建一个新的线程 myThread2 此线程进入新建状态
                myThread1.start();                 // 调用start()方法使得线程进入就绪状态
                myThread2.start();                 // 调用start()方法使得线程进入就绪状态
            }
        }
    }
}

2、实现Runnable接口

实现步骤：

①、定义类实现Runnable接口;

②、重写Runnable接口中的run方法，在run方法中实现需要自定义的业务代码；

③、通过Thread类创建线程对象并将自定义的线程类作为参数传递给Thread类的构造函数；

④、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

??代码示例：

public class ThreadTest {
    class MyRunnable implements Runnable { //自定义线程类，实现Runnable接口
        private int i = 0;

        @Override
        public void run() { //重写线程执行方法体，根据需要实现的业务修改
            for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
                Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); // 调用start()方法使得线程进入就绪状态
                thread2.start();
            }
        }
    }
}

3、通过Callable和Future创建线程

实现步骤：

①、创建Callable接口的实现类，重写call()方法，作为线程执行体，且具有返回值；

②、创建Callable实现类的实例，使用FutrueTask类进行包装Callable对象，FutureTask对象封装了Callable对象的call()方法的返回值；

③、使用FutureTask对象作为Thread对象启动新线程;

④、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。

代码示例：

public class ThreadTest {
    public static void main(String[] args) {
        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }

        System.out.println("主线程for循环执行完毕..");
        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}


class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}

4、三种方式的对比

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

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

三、线程的几个主要概念

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

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

后面文章继续叙说多线程知识。