2022-08-05 10:49:13

操作系统中线程和进程的概念

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.(其实准确来讲，应该有三种，还有一种是实现Callable接口，并与Future、线程池结合使用，此文这里不讲这个。

Java线程的实现形式

这里继承Thread类的方法是比较常用的一种，如果说你只是想起一条线程。没有什么其它特殊的要求，那么可以使用Thread.

继承Thread类

扩展Thread类实现的多线程例子：

/** 
 * 测试扩展Thread类实现的多线程程序 
 */publicclassTestThreadextendsThread{publicTestThread(String name){super(name);}@Overridepublicvoidrun(){for(int i=0;i<5;i++){for(long k=0;k<100000000;k++);  
           System.out.println(this.getName()+":"+i);}}publicstaticvoidmain(String[] args){  
       Thread t1=newTestThread("李白");  
       Thread t2=newTestThread("屈原");  
       t1.start();  
       t2.start();}}

执行结果：

屈原:0
李白:0
屈原:1
李白:1
屈原:2
李白:2
屈原:3
屈原:4
李白:3
李白:4

实现Runnable接口

publicclassRunnableImplimplementsRunnable{private Stringname;publicRunnableImpl(String name){this.name= name;}@Overridepublicvoidrun(){for(int i=0; i<5; i++){for(long k=0;k<100000000;k++);  
           System.out.println(name+":"+i);}}}/** 
 * 测试Runnable类实现的多线程程序 
 */publicclassTestRunnable{publicstaticvoidmain(String[] args){  
       RunnableImpl ri1=newRunnableImpl("李白");  
       RunnableImpl ri2=newRunnableImpl("屈原");  
       Thread t1=newThread(ri1);  
       Thread t2=newThread(ri2);  
       t1.start();  
       t2.start();}}

输出：

C运行 : 0
D运行 : 0
D运行 : 1
C运行 : 1
D运行 : 2
C运行 : 2
D运行 : 3
C运行 : 3
D运行 : 4
C运行 : 4

说明： Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

1publicclassThreadTest{23publicstaticvoidmain(String[] args){45         Callable<Integer> myCallable=newMyCallable();// 创建MyCallable对象6         FutureTask<Integer> ft=newFutureTask<Integer>(myCallable);//使用FutureTask来包装MyCallable对象78for(int i=0; i<100; i++){9             System.out.println(Thread.currentThread().getName()+" "+ i);10if(i==30){11                 Thread thread=newThread(ft);//FutureTask对象作为Thread对象的target创建新的线程12                 thread.start();//线程进入到就绪状态13}14}1516         System.out.println("主线程for循环执行完毕..");1718try{19int sum= ft.get();//取得新创建的新线程中的call()方法返回的结果20             System.out.println("sum = "+ sum);21}catch(InterruptedException e){22             e.printStackTrace();23}catch(ExecutionException e){24             e.printStackTrace();25}2627}28}293031classMyCallableimplementsCallable<Integer>{32privateint i=0;3334// 与run()方法不同的是，call()方法具有返回值35@Override36public Integercall(){37int sum=0;38for(; i<100; i++){39             System.out.println(Thread.currentThread().getName()+" "+ i);40             sum+= i;41}42return sum;43}44

首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：

1publicclassFutureTask<V>implementsRunnableFuture<V>{23//....45}

1publicinterfaceRunnableFuture<V>extendsRunnable, Future<V>{23voidrun();45}

于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序，我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕…”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕…”的输出时机是没有任何问题的，那么为什么sum =4950会永远最后输出呢？

原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。

main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

原文链接
https://www.fangzhipeng.com/javainterview/2019/03/06/thread-basic.html