这篇文章主要讲的是Java的并发编程：创建线程的多种方式，如果不了解线程之间的各个状态的话，可以查看：Java的并发编程：线程状态以及各个线程状态的关系这篇文章。
Java的并发编程：创建线程的多种方式有下面这几种方式：
- 继承Thread类
- 实现Runnable接口
- 匿名内部类的方式
- 带返回值的线程
- 定时器（quartz）
- 线程池的实现
- Lambda表达式实现
- Spring实现多线程
继承Thread类创建Java线程
package com.breakyizhan.thread.t2;
public class Demo1 extends Thread {
public Demo1(String name) {
super(name);
}
@Override
public void run() {
while(!interrupted()) {
System.out.println(getName() + "线程执行了 .. ");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Demo1 d1 = new Demo1("first-thread");
Demo1 d2 = new Demo1("second-thread");
d1.start();
d2.start();
// d1.stop();
d1.interrupt();
}
}
实现Runnable接口创建Java线程
package com.breakyizhan.thread.t2;
/**
* 作为线程任务存在
*
* @author worker
*
*/
public class Demo2 implements Runnable {
@Override
public void run() {
while(true) {
System.out.println("thread running ...");
}
}
public static void main(String[] args) {
Thread thread = new Thread(new Demo2());
thread.start();
}
}
匿名内部类的方式创建Java线程
package com.breakyizhan.thread.t2;
public class Demo3 {
public static void main(String[] args) {
/*new Thread() {
public void run() {
System.out.println("thread start ..");
};
}.start();*/
/*new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread start ..");
}
}).start();*/
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("runnable");
}
}) {
public void run() {
System.out.println("sub");
};
}.start();
}
}
带返回值的线程
package com.breakyizhan.thread.t2;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Demo4 implements Callable<Integer> {
public static void main(String[] args) throws Exception {
Demo4 d = new Demo4();
FutureTask<Integer> task = new FutureTask<>(d);
Thread t = new Thread(task);
t.start();
System.out.println("我先干点别的。。。");
Integer result = task.get();
System.out.println("线程执行的结果为：" + result);
}
@Override
public Integer call() throws Exception {
System.out.println("正在进行紧张的计算....");
Thread.sleep(3000);
return 1;
}
}
定时器（quartz）创建Java线程
package com.breakyizhan.thread.t2;
import java.util.Timer;
import java.util.TimerTask;
public class Demo5 {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
// 实现定时任务
System.out.println("timertask is run");
}
}, 0, 1000);
}
}
线程池实现创建Java线程
package com.breakyizhan.thread.t2;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo6 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 1000; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
});
}
threadPool.shutdown();
}
}
Lambda表达式实现创建Java线程
package com.breakyizhan.thread.t2;
import java.util.Arrays;
import java.util.List;
public class Demo7 {
public static void main(String[] args) {
List<Integer> values = Arrays.asList(10,20,30,40);
int res = new Demo7().add(values);
System.out.println("计算的结果为：" + res);
}
public int add (List<Integer> values) {
// values.parallelStream().forEach(System.out :: println);
return values.parallelStream().mapToInt( i -> i * 2).sum();
}
}
Spring实现多线程创建Java线程在以后可以继续了解一下。