线程的创建

方法一：继承于Thread类

步骤

1、 创建一个继承于Thread类的子类
2、 重写Thread类中的run( )方法
3、 将此线程执行的操作声明在run方法中
4、 创建Thread类的子类对象
5、 通过此对象调用start( )方法

 *  start方法作用

     *  启动当前线程
     *  调用当前线程的run( )方法

代码实现

public class Test1 {
    public static void main(String[] args) {
        //3. 创建Thread类的子类对象
        MyThread myThread = new MyThread();
        //4. 通过此对象调用start()方法
        myThread.start();
    }
}

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2. 重写Thread类中的run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

注意事项

1、 不能通过直接调用run()的方式去启动线程，启动线程只能使用start()方法
2、 每个线程只能启动一次，如果多次启动，会报IllegalThreadStateException异常
3、 要想创建多个线程，就造多个对象

方法二：实现Runnable接口

步骤

1、 创建一个实现Runnable接口的类
2、 实现类去实现Runnable类中抽象方法：run()
3、 创建实现类的对象
4、 将此对象作为参数传入到Thread类中的构造器中，创建Thread类的对象
5、 通过Thread类的对象，调用start()

 *  start()作用

     *  启动线程
     *  调用当前线程的run()

         *  调用了Runnable类型的target的run()

代码实现

public class Test2 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MyselfThread myselfThread = new MyselfThread();
        //4. 将此对象作为参数传入到Thread类中的构造器中，创建Thread类的对象
        Thread thread = new Thread(myselfThread);
        //5. 通过Thread类的对象，调用start()
        thread.start();
    }
}

//1. 创建一个实现Runnable接口的类
class MyselfThread implements Runnable{
    //2. 实现类去实现Runnable类中的run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

方法一和方法二对比

两者联系

• Thread类本身也是实现了Runnable接口
• 都需要重写run()，将线程要实现的逻辑声明在run()方法中

优先选择实现Runnable接口的方式

原因：

1、 实现的方式没有类的单继承性的局限性
2、 实现的方式更适合来处理多个线程有共享数据的情况

方法三：实现Callable接口

比Runnable相比的好处

1、 可以有返回值

 *  需要借助Future接口

     *  可以对具体的Runnable、Callable任务的执行结果进行取消、查询是否完成获取结果等
     *  唯一的实现类是FutureTask

         *  同时实现了Runnable、Future接口
         *  既可以作为Runnable被线程执行，又可以作为Future得到

2、 方法可以抛出异常，被外面的操作捕获，获取异常的信息
3、 支持泛型的返回值

步骤

1、 创建一个实现Callable接口的实现类
2、 实现call方法，将此线程需要执行的操作声明在call方法中

 *  call方法可以有返回值

3、 创建Callable接口实现类的对象
4、 将此Callable接口的实现类对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
5、 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()方法调用
6、 获取Callable中的call方法的返回值

 *  使用futureTask.get()

     *  get()方法返回值即为FutureTask参数callable实现类重写call的返回值

代码实现

public class Test3 {
    public static void main(String[] args) {
        //3. 创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4. 将此Callable接口的实现类对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5. 将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()方法调用
        Thread thread = new Thread(futureTask);
        thread.start();
        //6. 获取Callable中的call方法的返回值
        try{
            Object sum = futureTask.get();
            System.out.println(sum);
        }catch (InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e){
            e.printStackTrace();
        }
    }
}

//1. 创建一个实现Callable接口的实现类
class NumThread implements Callable{

    //2. 实现call方法，将此线程需要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                sum = sum + i;
            }
        }
        return sum;
    }
}

方法四：使用线程池

好处

1、 提高响应速度
2、 降低资源消耗
3、 便于线程管理

步骤

1、 提供指定线程数量的线程池
2、 执行指定的线程操作，需要提供一个实现Runnable接口或Callable接口实现类的对象
3、 关闭连接池