1、继承Thread类
-
继承Thread类,重写run方法(即要让线程进行的操作),
-
创建线程实例,调用start()方法启动线程。
import java.util.Date;
/**
* @author: ycz
* @date: 2018/11/25 0025 15:48
* @description: 继承Thread方法
*/
public class MyThread extends Thread {
private final static int COUNT=100;
private String name;
public MyThread(String name) {
this.name = name; } @Override public void run() { for (int i=0;i<COUNT;i++) { System.out.println(Thread.currentThread().getName()+"--"+name+"---"+ new Date()); } } public static void main(String[] args) { MyThread p1 = new MyThread("zero"); MyThread p2 = new MyThread("one"); p1.start(); p2.start(); } }
2、实现runable接口
-
实现runable接口,重写run方法;
-
创建Runnable实现类的实例,并以此实例作为Thread的target对象,即该Thread对象才是真正的线程对象。
import java.util.Date;
/**
* @author: ycz
* @date: 2018/11/25 0025 16:02
* @description: 实现runable方法
*/
public class MyThread2 implements Runnable {
private final static int COUNT=100;
private String name;
public MyThread2(String name) {
this.name = name;
}
@Override
public void run() {
for (int i=0;i<COUNT;i++) {
System.out.println(Thread.currentThread().getName()+"--"+name+"---"+ new Date());
}
}
public static void main(String[] args) {
Runnable runnable = new MyThread2("zero");
Thread p1 = new Thread(runnable);
p1.start();
Runnable runnable2 = new MyThread2("one");
Thread p2 = new Thread(runnable2);
p2.start();
}
}
3、实现callable接口
-
实现callable接口重写call()方法,该方法为线程进行的操作,并且具有返回值;
-
创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。
-
使用FutureTask对象作为Thread对象的target创建并启动新线程。
-
调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中:
import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* @author: ycz
* @date: 2018/11/25 0025 16:17
* @description:
*/
public class MyThread3 implements Callable {
private final static int COUNT=100;
private String name;
public MyThread3(String name) {
this.name = name;
}
/**
* 重写call()方法;返回1~100的和
* @return
* @throws Exception
*/
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i=0;i<COUNT;i++) {
System.out.println(Thread.currentThread().getName()+"--"+name+"---"+ new Date());
sum += i;
}
return sum;
}
public static void main(String[] args) {
//创建callable()实例化对象
MyThread3 p1 = new MyThread3("zero");
//使用FutureTask类来包装Callable对象
FutureTask<Integer> futureTask = new FutureTask<Integer>(p1);
//使用FutureTask对象作为Thread对象的target创建并启动新线程
new Thread(futureTask).start();
Integer sum;
MyThread3 p2 = new MyThread3("one");
FutureTask<Integer> futureTask1 = new FutureTask<Integer>(p2);
new Thread(futureTask1).start();
Integer sum1;
try {
//等所有线程执行完,获取值,因此FutureTask 可用于 闭锁
sum = futureTask.get();
System.out.println("sum:"+sum);
sum1 = futureTask1.get();
System.out.println("sum1:"+sum1);
}catch (Exception e ){
e.printStackTrace();
}
}
}
参考:https://www.cnblogs.com/snow-flower/p/6114765.html