Java多线程编程
在Java中最大的特点是支持多线程的开发,所以在整个Java技术中,如果不能对多线程的概念有一个全面细致的了解,则在项目设计过程中尤其是并发访问的过程中出现严重的技术缺陷。
进程与线程
如果要理解线程,那么首先要理解进程的概念,在传统DOS时代,其本身特征:若出现病毒,那么所有程序无法执行,因为DOS采用的是单进程处理。而单进程处理的最大特点:在同一时间段只允许一个程序执行。
Windows开启了多进程设计,表示一个时间段上可以同时运行多个程序,这些程序会进行资源的轮流抢占。在同一时间段上会有多个程序依次执行,但是在同一个时间点上只会有一个进程执行,而到了多核CPU,由于可以处理的CPU多了,那么即便有再多的进程出现,也可以比单核CPU处理的速度有所提升。
线程:是在进程基础上划分的更小的程序单元,线程是在进程基础上创建并使用,所以线程依赖于进程的支持,但是线程的启动速度要比进程快很多,所以使用多线程进行并发处理时,其执行的性能要高于进程。
Java是多线程的编程语言,所以Java在进行并发访问处理的时候可以得到更高的性能。
继承Thread类实现多线程
要在Java中实现多线程的定义,需要一个专门的线程主体类进行线程的执行任务的定义,这个主体类的定义是有要求的,必须实现特定的接口或继承特定的父类才可以完成。
Java中提供有一个java.lang.Thread的程序类,只要继承此类表示为线程的主体类,但并不是说这个类就可以直接实现多线程处理,因为还需要覆写Thread类中提供的一个run方法,这个方法就属于线程的主方法。
多线程主体类
class MyThread extends Thread{ //实现线程的主体类,
private String title;
public MyThread(String title) {
this.title = title;
}
@Override
public void run() { //线程的主体方法
for(int x = 0; x<10; x++) {
System.out.println(this.title +"运行,x="+ x);
}
}
}
多线程要执行的功能都应该在run()中进行定义。需要说明的是:在正常情况下如果要使用一个类中的方法,那么肯定要产生实例化对象而后调用类中的方法,而run方法不能直接调用,这里面牵扯到资源调度问题,要想启动多线程必须**使用start()**方法。
虽然调用start方法,但最终执行的是run()方法,并且所有的线程对象都是交替执行的,但执行顺序不是可控的。
问:为什么不直接使用run而是必须使用Thread类中start方法呢?
在start()中会抛出一个"IllegalThreadStateException"异常类对象,但是程序并未进行处理,因为该异常是RunTimeException的之类。
每一个线程类的对象只允许启动一次,如果重复启动就抛出此异常。
MyThread mt = new MyThread("线程A");
mt.start();
mt.start(); //错误
在Java程序执行过程中考虑到对于不同层次开发者的需求,所以其支持有本地的操作系统函数调用,这项技术称为JNI,但并不推荐,利用这项技术可以使用一些操作系统提供的底层函数进行特殊处理,Thread类中提供的start0()方法就表示此方法需要依赖不同操作系统实现。
任何情况下,只要定义了多线程,多线程的启动永远只有一种方案:Thread类中的start()方法。
Runnable接口实现多线程
Java中对于继承存在单继承局限,所以在Java中提供第二种多线程定义结构:实现Java.lang.Runnable接口。
class MyThreadRun implements Runnable{ //实现线程的主体类,
private String title;
public MyThreadRun(String title) {
this.title = title;
}
@Override
public void run() { //线程的主体方法
for(int x = 0; x<10; x++) {
System.out.println(this.title +"运行,x="+ x);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
Thread thRun = new Thread(new MyThreadRun("线程B")); //Runnable实现
thRun.start();
}
}
但是此时不再继承Thread父类,此时类中也不再支持start()方法,此时使用Thread对象接收Runnable对象。
此时多线程可以发现,由于只是实现了Runnable接口对象,所以此时线程主体类上不再有单继承局限,这样的设计才是标准的设计。
现在Runnable为函数式编程接口所以可以直接使用Lambda表达式进行线程的实现。
public class ThreadDemo {
public static void main(String[] args) {
for(int x=0;x<3;x++) {
String title = "线程名称-"+x;
Runnable run = ()->{
for(int y = 0; y<10; y++) {
System.out.println(title +"运行,y="+ y);
}
};
new Thread(run).start();
}
}
}
以后开发中多线程优先考虑Runnable实现,永恒都是通过Thread类对象启动多线程。
Thread与Runnable的关系
从代码结构本身来讲使用Runnable是最方便的,因为其可以避免单继承的局限,同时也可以更好的进行功能的扩充。
但是从结构上也需要观察Thread与Runnable的联系。
public class Thread Object implements Runnable{}
发现Thread类也是Runnable接口的子类,那么之前继承Thread类的时候还是覆写的Runnable接口的run()方法。
多线程设计之中使用了代理设计模式的结构,用户自定义的线程主体知识负责项目核心功能的实现,而所有的辅助实现全部交由Thread类处理。
在进行Thread启动多线程的时候调用的是start()方法,而后找到的是run()方法。当通过Thread类的构造方法传递了一个Runnable的接口对象时,那么该接口对象将被Thread类中的target属性保存。在start()方法执行的时候会调用Thread类中的run()方法,而这个run()方法去调用Runnable接口子类被覆写过的run()方法。
多线程开发的本质实质上是在于多个线程可以进行同一资源的抢占,Thread主要描述的是线程,资源的描述是由Runnable完成的。
范例:利用买票程序实现多个线程的资源并发访问。
class MyThreadRun implements Runnable{ //实现线程的主体类,
private int ticket = 5;
private String title;
@Override
public void run() { //线程的主体方法
for(int x = 0; x<100; x++) {
if(this.ticket > 0 ) {
System.out.println(this.title +"买票,余票="+ this.ticket --);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThreadRun mt = new MyThreadRun();
new Thread(mt).start(); //第1个线程启动
new Thread(mt).start(); //第2个线程启动
new Thread(mt).start(); //第3个线程启动
}
}
Callable接口实现多线程
从最传统的开发来讲要进行多线程的实现肯定依靠的就是Runnable,但是Runnable的接口有一个缺点:当线程执行完毕之后无法获取一个返回值。所以从JDK1.5之后提出一个新的线程实现接口:java.util.concurrent.Callable。
@FunctionalInterface
public interface Callable<V>{
public V call() throws Exception;
}
发现Callable定义的时候可以设置一个泛型,此泛型的类型就是返回数据的类型。这样可以避免向下转型带来的安全隐患。
范例:使用Callable实现多线程处理
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyThreadRun implements Runnable{ //实现线程的主体类,
private int ticket = 5;
private String title;
@Override
public void run() { //线程的主体方法
for(int x = 0; x<100; x++) {
if(this.ticket > 0 ) {
System.out.println(this.title +"买票,余票="+ this.ticket --);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception{
FutureTask<String> task = new FutureTask<>(new MyThreadCal());
new Thread(task).start();
System.out.println("线程返回数据" + task.get());
}
}
面试:解释Runnable和Callable的区别?
- Runnable是在Jdk1.0提出的多线程实现接口,而Callable是JDK1.5提出的;
- Runnable接口中只提供run()方法且无返回值;
- Callable提供有call()方法,可以有返回值;
多线程运行状态
对于多线程的开发而言,编写程序的过程之中总是按照:定义线程主体类,而后通过Thread类进行线程的启动,然而并不意味着你调用了start()方法,线程就已经开始运行了,因为整体的线程处理有自己的一套运行的状态。
- 任何一个线程的对象都应该使用Thread类进行封装,所以线程的启动使用的是start(),但是启动的时候实际上若干个线程都将进入到一种就绪状态,现在并未执行;
- 进入就绪状态之后就需要等待进行资源调度,当某一个线程调度成功之后则进入到运行状态(run()方法),但是所有的线程不可能一直持续执行下去,中间需要产生一些暂停的状态,如某些线程执行一段时间之后就需要让出资源,而后这个线程就将进入到阻塞状态,然后重新回到就绪状态。
实际上若干个线程都将进入到一种就绪状态,现在并未执行; - 进入就绪状态之后就需要等待进行资源调度,当某一个线程调度成功之后则进入到运行状态(run()方法),但是所有的线程不可能一直持续执行下去,中间需要产生一些暂停的状态,如某些线程执行一段时间之后就需要让出资源,而后这个线程就将进入到阻塞状态,然后重新回到就绪状态。
- 当run()方法执行完毕之后,实际上该线程的主要任务也就结束了,此时就可以直接进入到停止状态。