创建线程的方式

一、继承Thread类，重写run方法。

//继承Thread类，并重写run方法
public class TextThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("子线程：" + i);
        }
    }
}

public static void main(String[] args) {
        //创建线程对象
        TextThread textThread = new TextThread();
        //启动线程 会自动调用run方法。
        textThread.start();

        //创建线程对象
        TextThread textThread1 = new TextThread();
        //启动线程 会自动调用run方法。
        textThread1.start();

        //这里如果直接调用run方法，则相当于普通方法调用，不会启动线程
//        textThread.run();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("主线程："+ i);        
           }
    }

输出结果

主线程：0
子线程：0
子线程：1
子线程：2
子线程：3
子线程：4
子线程：5
子线程：0
子线程：6
子线程：7
子线程：8
子线程：9
子线程：10
主线程：1
子线程：11
子线程：12
子线程：13
...

 

获取线程信息：

1、通过Thread类的子类获取线程信息。

//继承Thread类，并重写run方法
public class TextThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("子线程ID：" + this.getId()
                    + ",子线程名称：" + this.getName()
                    + ",子线程状态" + this.getState()
                    + ",子线程执行次数：" + i);
        }
    }
}

 

2、通过Thread类提供的方法获取当前线程信息。

for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("主线程ID：" + Thread.currentThread().getId()
                    + ",主线程名称：" + Thread.currentThread().getName()
                    + ",主线程状态" + Thread.currentThread().getState()
                    + ",主线程执行次数：" + i);        }
        }

打印结果：

主线程ID：1,主线程名称：main,主线程状态RUNNABLE,主线程执行次数：0
子线程ID：13,子线程名称：Thread-1,子线程状态RUNNABLE,子线程执行次数：0
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：0
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：1
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：2
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：3
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：4
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：5
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：6
子线程ID：12,子线程名称：Thread-0,子线程状态RUNNABLE,子线程执行次数：7
...

 

更新线程名称：

1、在线程启动之前更新。通过Thread类的子类调用线程对象的setName()方法。

public static void main(String[] args) {
        //创建线程对象
        TextThread textThread = new TextThread();
        //在线程启动之前更新。通过Thread类的子类调用线程对象的setName()方法
        textThread.setName("Thread一");
        //启动线程 会自动调用run方法。
        textThread.start();

        //创建线程对象
        TextThread textThread1 = new TextThread();
        //在线程启动之前更新。通过Thread类的子类调用线程对象的setName()方法
        textThread1.setName("Thread二");
        //启动线程 会自动调用run方法。
        textThread1.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("主线程ID：" + Thread.currentThread().getId()
                    + ",主线程名称：" + Thread.currentThread().getName()
                    + ",主线程状态" + Thread.currentThread().getState()
                    + ",主线程执行次数：" + i);
        }
    }

2、通过构造方法更新线程名称。

public class TextThread extends Thread {

    public TextThread(){
        super();
    }
    public TextThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("子线程ID：" + this.getId()
                    + ",子线程名称：" + this.getName()
                    + ",子线程状态" + this.getState()
                    + ",子线程执行次数：" + i);
        }
    }
}

public static void main(String[] args) {
        //创建线程对象
        TextThread textThread = new TextThread("Thread一");
        //启动线程 会自动调用run方法。
        textThread.start();

        //创建线程对象
        TextThread textThread1 = new TextThread("Thread二");
        //启动线程 会自动调用run方法。
        textThread1.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            //打印当前线程ID、名称、状态。
            System.out.println("主线程ID：" + Thread.currentThread().getId()
                    + ",主线程名称：" + Thread.currentThread().getName()
                    + ",主线程状态" + Thread.currentThread().getState()
                    + ",主线程执行次数：" + i);
        }
    }

输出结果：

子线程ID：12,子线程名称：Thread一,子线程状态RUNNABLE,子线程执行次数：0
子线程ID：12,子线程名称：Thread一,子线程状态RUNNABLE,子线程执行次数：1
子线程ID：12,子线程名称：Thread一,子线程状态RUNNABLE,子线程执行次数：2
子线程ID：12,子线程名称：Thread一,子线程状态RUNNABLE,子线程执行次数：3
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：0
主线程ID：1,主线程名称：main,主线程状态RUNNABLE,主线程执行次数：0
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：1
子线程ID：12,子线程名称：Thread一,子线程状态RUNNABLE,子线程执行次数：4
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：2
主线程ID：1,主线程名称：main,主线程状态RUNNABLE,主线程执行次数：1
主线程ID：1,主线程名称：main,主线程状态RUNNABLE,主线程执行次数：2
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：3
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：4
子线程ID：13,子线程名称：Thread二,子线程状态RUNNABLE,子线程执行次数：5
...

二、实现Runnable接口。

 

public class TextRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //打印线程信息
            System.out.println("子线程ID:" + Thread.currentThread().getId()
                    + ",子线程名称：" + Thread.currentThread().getName()
                    + ",子线程状态：" + Thread.currentThread().getState()
                    + ",子线程执行次数：" + i);
        }
    }
}

public static void main(String[] args) {
        //创建TextRunnable对象，表示要执行的功能
        TextRunnable runnable = new TextRunnable();
        //创建线程对象，将要执行的代码交由Thread管理。定义线程名称。
        Thread thread = new Thread(runnable, "我的线程1");
        //启动线程
        thread.start();
        //主线程执行信息
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i);
        }
    }

输出结果：

主线程：0
主线程：1
主线程：2
主线程：3
主线程：4
主线程：5
主线程：6
主线程：7
主线程：8
主线程：9
主线程：10
子线程ID:12,子线程名称：我的线程1,子线程状态：RUNNABLE,子线程执行次数：0
主线程：11
子线程ID:12,子线程名称：我的线程1,子线程状态：RUNNABLE,子线程执行次数：1
主线程：12
子线程ID:12,子线程名称：我的线程1,子线程状态：RUNNABLE,子线程执行次数：2
主线程：13
...

如果TextRunnable类我们只在这一处使用，则可以直接使用匿名内部类方式实现

public static void main(String[] args) {
        //创建线程对象，将要执行的代码交由Thread管理。定义线程名称。
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    //打印线程信息
                    System.out.println("子线程ID:" + Thread.currentThread().getId()
                            + ",子线程名称：" + Thread.currentThread().getName()
                            + ",子线程状态：" + Thread.currentThread().getState()
                            + ",子线程执行次数：" + i);
                }
            }
        }, "我的线程1");
        //启动线程
        thread.start();
        //主线程执行信息
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i);
        }
    }

也可简写为lambda表达式实现。

Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                //打印线程信息
                System.out.println("子线程ID:" + Thread.currentThread().getId()
                        + ",子线程名称：" + Thread.currentThread().getName()
                        + ",子线程状态：" + Thread.currentThread().getState()
                        + ",子线程执行次数：" + i);
            }
        }, "我的线程1");

 

3、实现Callable接口。

public interface Callable<V> {
 
    V call() throws Exception;
}

 

public static void main(String[] args) throws ExecutionException, InterruptedException {
        //实例化Callable对象，使用lambda形式
        Callable<Integer> callable = () -> {
            System.out.println(Thread.currentThread().getName() + "开始计算...");
            int result = 0;
            for (int i = 1; i <= 100; i++) {
                result += i;
            }
            return result;
        };
        //将callable对象转为可执行任务
        FutureTask<Integer> task = new FutureTask<>(callable);
        //创建线程，将task交由线程来操作
        Thread thread = new Thread(task);
        //线程启动
        thread.start();
        //获取任务结果（等到callable执行完毕，才会返回结果）
        Integer result = task.get();
        System.out.println("结果是：" + result);
    }

输出结果：

Thread-0开始计算...
结果是：5050

 

4、线程池。