Java多线程开发（进程与线程）

Java多线程开发

进程与线程

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

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

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

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

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

以执行多进程

• 单进程在同一时间只允许一个程序执行

• 线程是在进程基础上划分的更小程序单元单元

• 线程依赖进程支持

• 线程启动速度快于进程

• 进程是在操作系统上的划分，线程是在进程上的划分

Thread类实现多线程

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

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

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

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

public class DoAnotherThing extends Thread {
    public void run(){
        // here is where you do something
        //在这里描写多线程的功能
    }
}

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

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

public void start（）

...
DoAnotherThing doIt = new DoAnotherThing();
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（）方法

接下来我们看下用法

范例:

public class mythread implements Runnable {//实现Runnable
    public void run(){
        // here is where you do something
        //在这里描写多线程的功能
    }
}
public class ThreadDemo{
 public static void main(String[] args)
    {
        Thread  mt=new Thread(new mythread());
        mt.start();
    }
}

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

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

构造方法

Thread的构造方法

public Thread(Runnable target);

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

public class ThreadDemo{
 public static void main(String[] args)
    {
        Thread  mt=new Thread(new mythread());//创建Thread对象，传入Runnable对象
        mt.start();//调用Thread当中的start（）方法实现多线程
    }
}

补充：使用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();
       }
    }
}

Thread与Runnable的关系

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

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

Thread与Runnable的关系：

范例：

class mythread implements Runnable{
    private int ticket=5;
    private string title;
    public mythread(String title)
    {
        this.title=title;    
    }
    @Override
    public void run{
        for(int x=0;x<100;x++)
        {
            if(this.title>0)
            {
               System.out.println("卖票，title="+this.ticket--)              
            }
                   
        }    
    }
}
public class threaddemo{
    public static void main(String[] args)
    {
        mythread mt=new mythread();
        new Thread(mt).start();//第一个线程启动
        new Thread(mt).start();//第二个线程启动
        new Thread(mt).start();//第三个线程启动
        
    }
}

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

Callable接口实现多线程

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

接口的定义：

@FunctionalInterface
public interface Callable<V>
{
	public v call() throws Exception;
}

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

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

范例：

import java.util.concurrent.Callabe;
import java.util.concurrent.FutureTask;
class mythread implements Callable<String>{
    @Override
    public String call() throws Exception{
          System.out.println("******线程执行********，x="+x)       
    }
    return "线程执行完毕";
}
public class ThreadDemo{
    public static void main(String[] args) throws Exception{
         FutureTask<String> task=new FutureTask<>(new mythread());
         new Thread(task).start();
         System.out.println("【线程返回数据】"+task.get());           
    }
}

多线程运行状态

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