Java 线程的创建

方式一：继承Thread类，覆盖run()方法

步骤：

1. 定义类，并继承Thread类
2. 在类里，覆盖run()方法
3. 创建对象实例
4. 启动线程

• 实例：龟免赛跑

乌龟线程

package thread;

/**
 * 定义线程类，继承Thread类
 */
public class Tertoise extends Thread {
    /**
     * 覆盖run方法
     */
    @Override
    public void run() {
        while (true)
            System.out.println("乌龟跑前面啦｀｀｀｀｀"+this.getName()+": "+ this.getPriority());
    }
}

兔子线程

package thread;

public class Rubbit extends Thread {
    @Override
    public void run() {
        while (true)
            System.out.println("兔子跑前面啦。。。。。。。"+this.getName()+": "+ this.getPriority());
    }
}

测试程序

package thread;

public class ThreadCreate {
    public static void main(String[] args) {
        /**
         * 创建线程实例
         */
        Tertoise tertoise = new Tertoise();
        Rubbit rubbit = new Rubbit();

        /**
         * 启动线程
         */
        tertoise.start();
        rubbit.start();
    }
}

效果图

方式二：实现Runnable接口，并实现run方法

步骤：

1. 定义类，并实现Runnable接口
2. 在类里，实现run()方法
3. 创建Runnable对象实例
4. 创建Thread实例，并把Runnable对象当做参数传给Thread构造函数
5. 启动线程

• 实例：龟免赛跑

定义类，并实现Runnable接口

package thread;

public class RunnableCreate implements Runnable {
    @Override
    public void run() {
        while (true){
            System.out.println(Thread.currentThread().getName()+"跑前面啦｀｀｀｀｀"+ 
                    Thread.currentThread().getPriority());
        }
    }
}

测试程序

package thread;

public class TestRunnable {
    public static void main(String[] args) {
        //创建Runnable对象实例
        RunnableCreate r = new RunnableCreate();
        
      //  创建Thread实例，并把Runnable对象当做参数传给Thread构造函数
        Thread tortoise = new Thread(r);
        tortoise.setName("乌龟------");

        Thread rubbit = new Thread(r);
        rubbit.setName("兔子+++++++");
      //启动线程
        tortoise.start();
        rubbit.start();
    }
}

效果图

两种创建线程方式的比较

Runnable接口使用例子：卖票系统，多个窗口共同卖票

Thread 常用的方法

匿名内部类的使用

例子

• 要创建多个线程，只在一个类内使用的情况

package thread;

public class TestRunnable {
    public static void main(String[] args) {

        RunnableCreate r = new RunnableCreate(){
            @Override
            public void run() {
                while (true){
                    System.out.println(Thread.currentThread().getName()+"跑前面啦｀｀｀｀｀"+
                            Thread.currentThread().getPriority());
                }
            }
        };
        Thread tortoise = new Thread(r);
        tortoise.setName("乌龟------");

        Thread rubbit = new Thread(r);
        rubbit.setName("兔子+++++++");

        tortoise.start();
        rubbit.start();
    }
}

• 只创建一个线程，只在一个类内使用的情况

package thread;

public class TestRunnable {
    public static void main(String[] args) {
        Thread rubbit = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println(Thread.currentThread().getName()+"跑前面啦｀｀｀｀｀"+
                            Thread.currentThread().getPriority());
                }
            }
        });
        rubbit.setName("兔子+++++++");

        rubbit.start();
    }
}

方式三：实现Callable接口

步骤：

1. 定义类，并实现Callable接口
2. 在类里，实现call()方法
3. 创建Callable对象实例
4. 创建FutureTask实例，并把Callable对象当做参数传给FutureTask构造函数
5. 创建Thread实例，并把FutureTask对象当做参数传给Thread构造函数
6. 启动线程
7. 拿到返回值

例子：打印10以内的随机数

package thread;

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

public class RandomCallable implements Callable {
    @Override
    public Integer call() throws Exception {
        return new Random().nextInt(10);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 定义接口对象，并创建线程实例
         */
        Callable callable = new RandomCallable();
        FutureTask task = new FutureTask<>(callable);
        Thread thread = new Thread(task);

        //启动线程
        thread.start();

        //拿到返回值
        Integer result=task.get();
        System.out.println(result);
    }
}

效果图