线程的创建和使用

转载

mob604757044d68 2021-02-08 22:43:00

线程的创建

方式一：创建继承Thread类的子类，需要重写父类的run()方法，然后创建子类的对象，通过子类对象调用start()方法（包括采用匿名子类）。

小案例：

package com.threadstudy;

public class MultiThreadingTest1 {
    public static void main(String[] args) {
        MyThread1 myThread = new MyThread1();
        myThread.start();
        //如果直接调用run方法不属于多线程，因为没有开启新线程
        //myThread.run();
        //同一个新线程的对象不能重复start启动，如想重新启动新线程，需要创建一个新的对象
        //myThread.start();//运行报错：java.lang.IllegalThreadStateException
        System.out.println("我是主线程");

        //匿名子类写法创建多线程
        new Thread() {
            @Override
            public void run() {
                // 此线程执行需要执行的操作声明在run中
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("我是匿名子类新线程");
            }
        }.start();
        //main方法中可以同时创建多个匿名子类线程
        //.......
    }
}
class MyThread1 extends Thread {
    @Override
    public void run() {
        // 此线程执行需要执行的操作声明在run中
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("我是新线程");
    }
}

运行结果：

我是主线程

我是新线程

我是匿名子类新线程

方式二：创建实现Runnable的类，实现Runnable中的抽象方法run(),创建类的对象，将此对象传入Thread类的构造器中创建Thread类的对象，调用Thread类的对象的start()方法（包括匿名写法）。

小案例：

package com.threadstudy;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 */
public class MultiTheadingTest2 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread thread = new Thread(myThread2);
        thread.start();
        System.out.println("我是主线程");
        //匿名写法
        new Thread(
                new Runnable() {
                    public void run() {
                        // 此线程执行需要执行的操作声明在run中
                        int sum = 0;
                        for (int i = 0; i <= 100; i++) {
                            sum += i;
                        }
                        System.out.println("我是匿名新线程");
                    }
                }).start();
    }

}

class MyThread2 implements Runnable {

    public void run() {
        // 此线程执行需要执行的操作声明在run中
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("我是新线程");
    }
}

方式三：JDK5.0新特性。实现Callable接口。需要借助Future接口的唯一实现类FutureTask辅助线程的对象创建和返回值获取（FutureTask还实现了Runnable接口），再创建Thread对象，将FutureTask类的对象作为构造器参数传入，完成线程的创建，最后调用start()方法完成线程启动。

小案例：

package com.threadstudy;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MultiThreadTest3 {
    public static void main(String[] args) {
        MyThread3 myThread3 = new MyThread3();
        FutureTask futureTask = new FutureTask(myThread3);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            Object sum = futureTask.get();
            //System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("我是主线程");

        // 匿名写法
        new Thread(new FutureTask(new Callable() {

            public Object call() throws Exception {
                // 此线程执行需要执行的操作声明在call中
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("我是匿名新线程");
                return sum;// int类型赋值给Object,自动装箱
            }
        }) ).start();
    }
}

class MyThread3 implements Callable {

    public Object call() throws Exception {
        // 此线程执行需要执行的操作声明在call中
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("我是新线程");
        return sum;// int类型赋值给Object,自动装箱
    }
}

运行结果：

我是新线程

我是主线程

我是匿名新线程

方式四：JDK5.0新特性。使用线程池，提前创建好多个线程放入线程池中，使用时直接获取，使用完放回线程池中。可以做到提高响应速度（减少线程创建的时间）和降低资源消耗（可重复利用线程）。利用Executors工具类创建线程池，然后提供Runnable(excute())或Callable(submit())接口的实现类的对象，执行指定线程的操作。最后，关闭线程池shutdown()。

小案例：

package com.threadstudy;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadTest4 {
    public static void main(String[] args) {
        // 利用工具类Executors创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        threadPool.submit(new MyThread4());// 适用于实现Callable接口的线程
        threadPool.execute(new MyThread5());// 适用于实现Runnable接口的线程
        threadPool.shutdown();
    }
}

class MyThread4 implements Callable {

    public Object call() throws Exception {
        // 此线程执行需要执行的操作声明在call中
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("我是CALL新线程");
        return sum;
    }

}

class MyThread5 implements Runnable {

    public void run() {
        // 此线程执行需要执行的操作声明在call中
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("我是RUN新线程");
    }

}

运行结果：

我是CALL新线程

我是RUN新线程