一.概念
(1)什么是线程?
线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个任务要100毫秒,那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持。
(2)和进程有什么关系?
线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的 线程共享一片相同的内存空间。别把它和栈内存搞混,每个线程都拥有单独的栈内存用来存储本地数据。
二.实现方式
(1)有几种实现方式
Java创建线程的4种方式
1.通过Thread类,重写run方法
2.实现Runnable接口,重写run方法,实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程
区别:
实现方式区别:
(1)Thread和Runnable可以归结为一类:无返回值,原因很简单,通过重写run方法,run方式的返回值是void,所 以没有办法返回结果 ;Callable/FutureTash和线程池创建可以归结成一类:有返回值,通过Callable接口,就要实现call 方法,这个方法的返回值是Object,所以返回的结果可以放在Object对象中
(2)Thread和Runnable不同,由于Thread属于继承,Runnable属于实现,而Java只允许有一个继承,但可以有多个 实现,所以在使用方式还是有区别
(3) Runnable的代码可以被多个线程共享(Thread实例),适合于多个多个线程处理统一资源的情况
举例说明:模拟卖票,假设还剩5张票,分别采用两种方式来创建线程模拟
采用继承方式模拟3个窗口卖5张票的情况
public static void main(String[] args) {
MyThread mt1 = new MyThread("线程一");
MyThread mt2 = new MyThread("线程二");
MyThread mt3 = new MyThread("线程三");
// 启动线程
mt1.start();
mt2.start();
mt3.start();
}
static class MyThread extends Thread {
private int num = 5; // 共有5张票
private String name; // 线程名
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(num > 0) {
num--;
System.out.println(name + "卖出了一张票,剩余票数为:" + num);
}
}
}
运行结果,如下:通过结果得出每个窗口卖出5张票,共计15张票
线程一卖出了一张票,剩余票数为:4
线程一卖出了一张票,剩余票数为:3
线程一卖出了一张票,剩余票数为:2
线程一卖出了一张票,剩余票数为:1
线程一卖出了一张票,剩余票数为:0
线程二卖出了一张票,剩余票数为:4
线程三卖出了一张票,剩余票数为:4
线程二卖出了一张票,剩余票数为:3
线程三卖出了一张票,剩余票数为:3
线程二卖出了一张票,剩余票数为:2
线程三卖出了一张票,剩余票数为:2
线程三卖出了一张票,剩余票数为:1
线程三卖出了一张票,剩余票数为:0
线程二卖出了一张票,剩余票数为:1
线程二卖出了一张票,剩余票数为:0
采用Runnable实现
public static void main(String[] args) {
MyRunnable mt = new MyRunnable();
Thread mt1 = new Thread(mt, "线程一");
Thread mt2 = new Thread(mt, "线程二");
Thread mt3 = new Thread(mt, "线程三");
// 启动线程
mt1.start();
mt2.start();
mt3.start();
}
static class MyRunnable implements Runnable {
private int num = 5; // 共有5张票
@Override
public void run() {
// TODO Auto-generated method stub
while (num > 0) {
num--;
System.err.println(Thread.currentThread().getName() + "卖出了一张票,剩余票数为:" + num);
}
}
}
运行结果如下:
线程一卖出了一张票,剩余票数为:2
线程三卖出了一张票,剩余票数为:2
线程二卖出了一张票,剩余票数为:2
线程三卖出了一张票,剩余票数为:0
线程一卖出了一张票,剩余票数为:1
这样可以看出多个线程共享了Runnbale里面的5这个变量,至于结果为什么不是输出剩余票数4 3 2 1 0,这个是由于线程的调度问题造成的,每次运行都会看到不一样的结果
线程实现方式3:通过Callable和FutureTask创建线程
a:创建Callable接口的实现类 ,并实现Call方法
b:创建Callable实现类的实现,使用FutureTask类包装Callable对象,该FutureTask对象封装了Callable对象的Call方法的返回值
c:使用FutureTask对象作为Thread对象的target创建并启动线程
d:调用FutureTask对象的get()来获取子线程执行结束的返回值
public class ThreadDemo03 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Callable<Object> oneCallable = new Tickets<Object>();
FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
Thread t = new Thread(oneTask);
System.out.println(Thread.currentThread().getName());
t.start();
}
}
class Tickets<Object> implements Callable<Object>{
//重写call方法
@Override
public Object call() throws Exception {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
return null;
}
}
程序运行结果:
main
Thread-0–>我是通过实现Callable接口通过FutureTask包装器来实现的线程
线程实现方式4:通过线程池创建线程
public class ThreadDemo05{
private static int POOL_NUM = 10; //线程池数量
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
ExecutorService executorService = Executors.newFixedThreadPool(5);
for(int i = 0; i<POOL_NUM; i++)
{
RunnableThread thread = new RunnableThread();
//Thread.sleep(1000);
executorService.execute(thread);
}
//关闭线程池
executorService.shutdown();
}
}
class RunnableThread implements Runnable
{
@Override
public void run()
{
System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName() + " ");
}
}
程序运行结果:
通过线程池方式创建的线程:pool-1-thread-3
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-5
通过线程池方式创建的线程:pool-1-thread-2
通过线程池方式创建的线程:pool-1-thread-5
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-3
通过线程池方式创建的线程:pool-1-thread-2
ExecutorService、Callable都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,还有Future接口也是属于这个框架,有了这种特征得到返回值就很方便了。
通过分析可以知道,他同样也是实现了Callable接口,实现了Call方法,所以有返回值。这也就是正好符合了前面所说的两种分类
执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的,即:线程无返回结果,get方法会一直等待。
再介绍Executors类:提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int
corePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。