线程创建的三种方法
作者：互联网
线程创建的三种方法
1.第一种
-
package com.yang.thread;
/*
[1] 继承Thread类，重写run方法
[2] 使用start() 开启子线程
[3] 我们调用start()，底层调用的是start0(),底层不是java书写的--->run().
*/
//线程实现的第一种方式
public class Thread01 {
public static void main(String[] args) {
ThreadTest threadTest = new ThreadTest();
threadTest.setName("兔子");//给线程设置名字
threadTest.start();//开启线程
ThreadTest threadTest1 = new ThreadTest();
threadTest1.setName("乌龟");
threadTest1.start();
}
}
class ThreadTest extends Thread{//继承线程
@Override
public void run() {//重写run方法
for (int i = 1; i <=100 ; i++) {
System.out.println(Thread.currentThread().getName()+i+"m");
}
}
}
package com.yang.thread;
public class Thread02 {
public static void main(String[] args) {
//匿名内部类
Thread thread = new Thread(){
@Override
public void run() {
for (int i = 1; i <=100 ; i++) {
System.out.println(Thread.currentThread().getName()+i+"m");
}
}
};
thread.setName("兔子");
thread.start();
}
}
2.第二种
package com.yang.thread;
//创建线程的第二种方法
/*
实现Runnable接口，重写run方法。
直接调用start（）不可以开启线程。需要使用Thread有参构造进行开启线程。
*/
public class Thread03 {
public static void main(String[] args) {
//创建两个对象，和创建一个对象的区别在于资源是否共享。
MyThread my = new MyThread();
MyThread my1 = new MyThread();
Thread t = new Thread(my,"兔子");
Thread t1 = new Thread(my1,"乌龟");
t.start();
t1.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
/*
有三个线程，一个主线程main，还有两个子线程，，他们都是同时运行的。只是有主线程运行的快，所以先输出完。
*/
System.out.println("我在输出语句了");
}
}
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 1; i <=100 ; i++) {
System.out.println(Thread.currentThread().getName()+i+"m");
}
}
}
package com.yang.thread;
public class Thread04 {
public static void main(String[] args) {
//使用匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
//代码块
}
}, "线程A").start();
//使用lambda表达式 ()->{} 相当于重写了runnable中的run()方法。
new Thread(()->{
},"线程B").start();
}
}
3.第三种
package com.yang.thread;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//实现线程的第三种方式
//实现Callable
/*
可以有返回值
*/
//底层原理
//start() --> start0()-->run()->FutureTask 中的run()方法中调的是-->result = c.call()-->set(result)
// -->outcome = v返回值-->get()得到返回值。
public class Demo05 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable my = new MyCallable();
MyCallable my1 = new MyCallable();//这个一般写两个；主要看资源是不是共享
// FutureTask(Callable<V> callable)--->FutureTask<V> implements RunnableFuture<V>--->RunnableFuture<V> extends Runnable
//相等于一个中间转换FutureTask
//这是开启了两个线程
FutureTask<Integer> task = new FutureTask<>(my);
FutureTask<Integer> task1 = new FutureTask<>(my1);
Thread thread = new Thread(task,"兔子");
Thread thread1 = new Thread(task,"兔子");
thread.start();
thread1.start();
//获得当前线程结束后的返回值。thread.start();不能写在这之后，理解一下。
Integer integer = task.get();
Integer integer1 = task1.get();
System.out.println(integer);
System.out.println(integer1);
}
}
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int i = new Random().nextInt(10);
System.out.println(Thread.currentThread().getName()+i+"m");
return i;
}
}
package com.yang.thread;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo06 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int i = new Random().nextInt(10);
System.out.println(Thread.currentThread().getName()+i+"m");
return i;
}
});
new Thread(futureTask,"兔子").start();
System.out.println(futureTask.get());
}
}
总结
-
后两种方式可以避免Java中的单继承的局限性
-
需要返回值只能使用想实现Callable接口
-
不需要返回值推荐使用Runnable接口
-
线程池只能使用Runnable或者Callable类型参数，不能使用Thread类。
标签：线程,Thread,创建,start,三种,FutureTask,new,public 来源： https://www.cnblogs.com/yzlworld/p/16321550.html