方式一：继承Thread类，覆盖run()方法
步骤：
- 定义类，并继承Thread类
- 在类里，覆盖run()方法
- 创建对象实例
- 启动线程
- 实例：龟免赛跑
乌龟线程
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方法
步骤：
- 定义类，并实现Runnable接口
- 在类里，实现run()方法
- 创建Runnable对象实例
- 创建Thread实例，并把Runnable对象当做参数传给Thread构造函数
- 启动线程
- 实例：龟免赛跑
定义类，并实现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接口
步骤：
- 定义类，并实现Callable接口
- 在类里，实现call()方法
- 创建Callable对象实例
- 创建FutureTask实例，并把Callable对象当做参数传给FutureTask构造函数
- 创建Thread实例，并把FutureTask对象当做参数传给Thread构造函数
- 启动线程
- 拿到返回值
例子：打印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<Integer> {
@Override
public Integer call() throws Exception {
return new Random().nextInt(10);
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 定义接口对象，并创建线程实例
*/
Callable<Integer> callable = new RandomCallable();
FutureTask<Integer> task = new FutureTask<>(callable);
Thread thread = new Thread(task);
//启动线程
thread.start();
//拿到返回值
Integer result=task.get();
System.out.println(result);
}
}
效果图
