Java有三种创建线程的方式,分别是继承Thread类、实现Runable接口和使用线程池
1、继承Thread类
使用该方式创建及使用线程需按以下三个步骤:
(1)定义Thread类的子类,并重写父类的run()方法,方法里的内容就是线程所要执行的任务;
(2)创建子类的实例,即生成线程的实例对象;
(3)调用现成的start()方法来启动线程。
public class SubThread extends Thread {
private int ticket = 100;
private String name;
public ImplThread(String name) {
this.name = name;
}
public void run() {
while (k > 0){
System.out.println(ticket-- + "is saled by" + name);
}
try{
sleep((int)Math.random() * 10);
}catch (InterruptedException e){
e.printStackTrace();
}
}
public static void main (String []args){
SubThread t1 = new SubThread("A");
SubThread t2 = new SubThread("B");
t1.start();
t2.start();
}
}
2、实现Runnable接口
(1)定义实现Runnable接口的实现类,并重写run()方法;
(2)创建Runnable接口实现类的实例,并将该实例作为参数传到Thread类的构造方法中来创建Thread对象,该Thread对象才是真正的线程对象;
(3)调用现成的start()方法来启动线程。
public class ImplThread implements Runnable {
private int ticket = 100;
private String name;
public ImplThread(String name) {
this.name = name;
}
public void run() {
while (k > 0){
System.out.println(ticket-- + "is saled by" + name);
}
try{
sleep((int)Math.random() * 10);
}catch (InterruptedException e){
e.printStackTrace();
}
}
public static void main (String []args){
ImplThread i1 = new ImplThread("A");
ImplThread i2 = new ImplThread("B");
Thread t1 = new Thread(i1);
Thread t2 = new Thread(i2);
t1.start();
t2.start();
}
}
上面这段代码跟继承Thread类的线程代码呈现的效果是一样的,虽然执行的是相同的代码,但彼此相互独立,且各自拥有自己的资源,互不干扰。
但是,在某些场景,我们希望各线程能共享资源,这时候就只能扩展Runnable接口了。
public class ImplThread implements Runnable {
private int ticket = 100;
public void run() {
while (k > 0){
System.out.println(ticket-- + "is saled by" + Thread.currentThread());
}
try{
sleep((int)Math.random() * 10);
}catch (InterruptedException e){
e.printStackTrace();
}
}
public static void main (String []args){
ImplThread i = new ImplThread();
Thread t1 = new Thread(i);
Thread t2 = new Thread(i);
t1.start();
t2.start();
}
}
这时候,线程t1和t2共享这100张票。
3、使用线程池
使用线程池并不是创建线程,而是对线程进行管理。Excetor为线程池超级接口,该接口中定义了一个execute(Runnable command)方法,用来执行传递过来的线程,ExecutorService就是我们所说的线程池,它继承了Excetor接口。如何创建线程池呢?Java提供了Executors类,该类有四个静态方法分别可以创建不同类型的线程池(ExecutorService)。
Executors.newCachedThreadPool() 创建可变大小的线程池
Executors.newFixedThreadPool(int number) 创建固定大小的线程池
Executors.newSingleThreadPool() 创建单任务线程池
Executors.newScheduledThreadPool(int number) 创建延迟线程池
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class Test {
public static void main(String[] args) {
//创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//关闭线程池
pool.shutdown();
}
}
class MyThread extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"正在执行。。。");
}
}
输出:
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-1正在执行。。。
pool-1-thread-2正在执行。。。
Process finished with exit code 0
可见,线程得到了重用,线程池里只有两个线程在执行。