Java高级

Java高级开发入门

Java多线程开发

进程与线程

我们明白java是为数不多的支持多线程开发

因为在原来DOS采取单线程，但是每当有病毒出现程序将无法执行，因此我

们需要进行多线程开发，来避免这种程序无法执行的状态

windows开启多进程设计，在同一时间段上同时运行多个程序并且这些程序

将依次执行，但是在同一个时间点上只会有一个程序执行（单核），多核可

以执行多进程

• 单进程在同一时间只允许一个程序执行
• 线程是在进程基础上划分的更小程序单元单元
• 线程依赖进程支持
• 线程启动速度快于进程
• 进程是在操作系统上的划分，线程是在进程上的划分

Thread类实现多线程

通过继承Thread类可以实现多线程

可以看java.lang.Thread是Object的子类

在继承Thread程序类时，需要覆写run（）方法public void run（）

多线程要执行的功能都应该在run（）方法中定义

publicclassDoAnotherThingextendsThread{publicvoidrun(){// here is where you do something//在这里描写多线程的功能}}

但是我们不应该直接调用run（）方法

要想启动多线程必须使用start（）方法完成

public void start（）

...DoAnotherThing doIt =newDoAnotherThing();
doIt.start();//在这里我们没有调用run（）方法，而是调用start（）方法...

我们可以把多线程的调度当作赛跑，run（）方法就是在调度运动员在赛道上

做准备但是真正比赛的开始还是要看start（）方法，start（）方法就像信号

枪，只有调度了start（）方法才能够真正开始多线程

值得注意的是虽然调用了start（）方法，但最终执行的是run()方法

start（）方法会抛出一个IllegalTHreadStateException异常对象但整个程序并

没有try…catch处理，因此该异常一定是RuntimeException的子类，每个线程

类对象只允许启动一次，如果重复启动就会抛出异常

Thread的执行分析
以下以一张图进行总结：

任何情况下，只要定义了多线程，多线程的启动永远只有一种方案：Tread类中的start（）方法

Runnable实现多线程

Java里面提供第二种多线程主体定义结构形式:实现Java.lang.Runnable接口

从jdk1.8以后引入lambda表达式以后就变为了函数式接口

可以看出Runnable只有一个run（）方法

接下来我们看下用法

范例:

publicclass mythread implementsRunnable{//实现Runnablepublicvoidrun(){// here is where you do something//在这里描写多线程的功能}}publicclassThreadDemo{publicstaticvoidmain(String[] args){Thread  mt=newThread(newmythread());
        mt.start();}}

从上方代码我们可以看出由于没有继承Thread类，但是我们又必须要使用

Thread类里面的start（）方法实现多线程，于是我们就需要去观察Thread的

构造方法

Thread的构造方法

publicThread(Runnable target);

也就是说我们可以传入一个实现Runnable的对象然后再去调用start（）方法

publicclassThreadDemo{publicstaticvoidmain(String[] args){Thread  mt=newThread(newmythread());//创建Thread对象，传入Runnable对象
        mt.start();//调用Thread当中的start（）方法实现多线程}}

补充：使用lambda表达式实现多线程

publicclassThreadDemo{publicstaticvoidmain(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);}};newThread(run).start();}}}

Thread与Runnable的关系

我们可以看出Runnable作为接口可以实现多继承，解决了Thread只能单继承

的难题,同时也可以更好进行功能的扩充

Thread与Runnable的关系：

范例：

class mythread implementsRunnable{privateint ticket=5;private string title;publicmythread(String title){this.title=title;}@Overridepublicvoid run{for(int x=0;x<100;x++){if(this.title>0){System.out.println("卖票，title="+this.ticket--)}}}}publicclass threaddemo{publicstaticvoidmain(String[] args){
        mythread mt=newmythread();newThread(mt).start();//第一个线程启动newThread(mt).start();//第二个线程启动newThread(mt).start();//第三个线程启动}}

三个线程都同时对同一个对象操作

Callable接口实现多线程

Runnable接口无法在完成后获取一个返回值，所以出现Java.util.concurrent.Callable接口可以在线程完成后返回一个值

接口的定义：

@FunctionalInterfacepublicinterfaceCallable<V>{public v call()throwsException;}

由于我们返回的值并不确定，所以在这里我们需要设置泛型

在方法介绍上，说明又时候我们并不一定都可以正常结束返回结果，这时就需要我们记得抛出异常

范例：

importjava.util.concurrent.Callabe;importjava.util.concurrent.FutureTask;class mythread implementsCallable<String>{@OverridepublicStringcall()throwsException{System.out.println("******线程执行********，x="+x)}return"线程执行完毕";}publicclassThreadDemo{publicstaticvoidmain(String[] args)throwsException{FutureTask<String> task=newFutureTask<>(newmythread());newThread(task).start();System.out.println("【线程返回数据】"+task.get());}}

多线程运行状态

• 任何一个线程的对象都应该使用Thread类进行封装，所以线程的启动使用的start（）方法，但是启动的时候实际上若干个线程将进入到一种就绪状态，现在没有执行；
• 进入到就绪状态后就需要等待进行资源调度，当某个线程调度成功后则进入到运行状态（run（）方法），但是所有的线程不可能一直持续执行下去，中间需要产生一些暂停的状态，例如：某个线程执行一段时间之后就需要让出资源，而后这个线程将进入到阻塞状态，随后重新回归到就绪状态；
• 当run（）方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时就可以直接进入到停止状态