创建一个多线程的方法
-
继承Thread类
public class MyThread extends Thread{
//继承Thread类,然后重写run方法;
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("MyThread线程=" + i);
}
}
}
public class ThreadDemo1 {
//main是程序的默认的主线程
public static void main(String[] args) {
//创建一个继承了Thread类的对象
Thread t = new MyThread();
//调用start方法启动线程,注意启动线程是start方法,而不是run方法;
t.start();//start()是向CPU注册一个单独的执行流程,那么CUP就会把t作为一个单独的执行流程来执行
//注意不要把主线程的任务放在启动子线程之前,不然就没意义了
for (int i = 0; i < 5; i++) {
System.out.println("main主线程=" + i);
}
}
}
注意事项:
1,线程的启动时start方法而不是run方法。如果调用了run方法,就会被当成普通的方法执行,此时还是相当于单线程;而start方法是向CPU注册一个单独的执行流程,那么CUP就会把它作为一个单独的执行流程来执行
2,注意不要把主线程的任务放在启动子线程之前,不然主线程任务跑完,然后再执行多线程的任务,那不就没意义了。
-
实现Runnable接口
//1,让一个类实现Runnable接口
public class MyRunnable implements Runnable{
//2,重写run方法;
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程--》" + i);
}
}
}
--------------------------------------------------
public class ThreadTest2 {
public static void main(String[] args) {
//3,在类中new一个对象
Runnable myRunnable = new MyRunnable();
//4,再new一个Thread线程对象,调用线程对象的有参构造器public Thread(Runnable target);
//5,然后把实现Runnable接口的对象放进构造器去,调用线程对象的start方法即可
new Thread(myRunnable).start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程--》" + i);
}
}
}
实现Runnable接口创建多线程的优点是可以继续继承其他的类,实现其他的接口,扩展性强。缺点硬要说的话就是多一个Runnable对象(其实没啥)
-
使用匿名内部类的形式创建多线程
public class ThreadTest3 {
public static void main(String[] args) {
//1,直接创建一个Runnable接口的匿名内部类(任务对象)
//第一种写法
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程1--》" + i);
}
}
};
new Thread(target).start();
//也可以直接更简化的写法
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程2--》" + i);
}
}
}).start();
//因为Runnable接口带有@FunctionalInterface(函数式接口)的注解,所以他还可以用Lambda表达式来简化
new Thread(() ->{
for (int i = 0; i < 5; i++) {
System.out.println("子线程3--》" + i);
}
}).start();
//主线程
for (int i = 0; i < 5; i++) {
System.out.println("主线程--》" + i);
}
}
}
其实还是使用实现Runnable接口,然后创建一个线程对象这样的方式来做的,只不过不是一个单独的类,而是匿名内部类来实现而已;
-
实现Callable<V>接口:最大的不同是这种方式多线程跑完可以获取返回值;
//1,创建一个类,实现Callable接口,<V> 可以设置返回值类型
public class CallableTest implements Callable<String> {
//通过私用属性n来充当下面call方法的传入参数;
private int n ;
public CallableTest(int n) {
this.n = n;
}
//2,重写Call方法;
//重写的call方法,没有办法直接传入参数,但是可以在类中声明一个私有属性,来充当参数:
@Override
public String call() throws Exception {
int sum = 0 ;
for (int i = 1; i <= n; i++) {
sum += i ;
}
//Thread.sleep(1000);
return "您求的1到" + n + "的和为:" + sum;
}
}
------------------------------------------------------
public class MyCallable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//3创建一个Callable的实例
//这里的100是我设置的构造器需要带参数而已;
Callable<String> call = new CallableTest(100);
//4,Callable自己并不是一个线程对象,需要把他封装到FutureTask未来任务的对象里
//FutureTask是实现了Runnable接口的
FutureTask<String> futureTask = new FutureTask<>(call);
//5,然后在创建一个线程对象,把实现Runnable接口的FutureTask对象放进去;
new Thread(futureTask).start();
//然后可以调用FutureTask的get方法获取返回值;
//注意这里,如果线程没跑完,遇到这个调用返回值的代码他会暂停,不会执行下面的代码
String s = futureTask.get();
//System.out.println("hi");
}
}
重点是通过FutureTask的get()方法,可以获取多线程的返回值;