进程与多线程实现

た入场券 2023-06-10 05:30 6阅读 0赞

进程：进程就是起运一段程序，将这段程序加载进入内存，并为其分配相关资源，是资源分配的最小  
单位。  
线程：线程是比进程更小一级的单位，一个进程中可以有多个线程同时存在，并执行相关任务，是计  
算机最小的调度单元。  
线程和进程有何不同？  
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，线程可以共享资源，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序。

什么是多线程？  
指在同一个间段内程序运行多个子任务，而多个子任务是几乎同时运行（操作者），在计算机层面，是多个任务一直切换，速度很快，导致的结果。

java多线程的实现：  
有三种实现方式：  
1.继承Thread类创建线程类  
2.实现Runnable接口创建线程类  
3.使用Callable和Futere创建线程

继承Thread类来创建新线程
    package thread_thread;
    
    public class myThread extends Thread{
        
    	
    	@Override
    	public void run() {
        
    		for (int i = 0; i <20; i++) {
        
    			System.out.println(getName()+i);
    		}
    	}
    }
    
    
    
    package thread_thread;
    /**
     *  利用继承Thread类创建多线程
     * 1.继承Thread类
     * 2.重写run方法
     * 3.创建Thread子类实例对象
     * 4.调用start()方法开启多线程
     * 注意：调用start()方法而不是调用run方法
     * 调用run方法只是单纯的调用一个方法，还是main线程在单独执行，而不会创建新的线程
     * 调用start()方法会创建新的线程
     * void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法
     * 	start()方法只能执行一次，不能多次调用否则会抛出异常：
     * 	java.lang.IllegalThreadStateException
     * @author DELL
     *
     */
    public class myThreadTest{
        
    	public static void main(String[] args) {
        
    		Thread mt=new myThread();
    		mt.start();
    		for(int i=0;i<20;i++) {
        
    			System.out.println(Thread.currentThread().getName()+i);
    		}
    		mt.start();
    	}
    }

提倡这种使用Runnable接口编程——面向接口编程
    package thread_runnable;
    
    public class Runnableimpl implements Runnable{
        
    
    	@Override
    	public void run() {
        
    		for(int i=0;i<20;i++) {
        
    			System.out.println(Thread.currentThread().getName()+i);
    		}
    	}
    	
    }
    
    
    
    package thread_runnable;
    /**
     * 实现多线程：第二种方法——实现Runnable接口
     * 1.类实现Runnable接口
     * 2.实现接口中的run()方法
     * 3.创建该类的实例对象
     * 4.创建Thread实例并将Runnable实例当做参数传递进去创建线程
     * 5.调用Thread的start()方法开启线程
     * 注意：提倡使用这种方式开启多线程，因为第一种继承Thread的方法会使子类受限，
     * 而第二种方式面向接口编程，可以使子类摆脱单继承的束缚
     * @author DELL
     *
     */
    public class RunnableimplTest {
        
    	public static void main(String[] args) {
        
    		Runnableimpl myrun=new Runnableimpl();
    		new Thread(myrun).start();
    		for(int i=0;i<20;i++) {
        
    			System.out.println(Thread.currentThread().getName()+i);
    		}
    	}
    }

Callable接口实际和Runnable接口一样，都是用来对于多线程实现的补充，

> 不一样的地方在于：Callable的call()方法允许抛出异常，并可以有返回值，但是Runnable的run方法不行。

Future的实现类FutureTask不仅实现了Future还实现了Runnable接口，因此可以使用此类将Runnable或者Callable接口的实现类对象包装为一个任务交给线程，

> FutureTask(Callable callable)  
> 创建一个 FutureTask，一旦运行就执行给定的 Callable。

FutureTask(Runnable runnable, V result)  
创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。

如果Runnable接口实现类没有返回结果：则使用如下方法构造  
Future<?> f = new FutureTask(runnable, null)

package thread_callable;
    
    import java.util.concurrent.Callable;
    
    public class callableimpl implements Callable<Integer>{
        
    	private int a=0;
    	@Override
    	public Integer call() throws Exception {
        
    		for(int i=0;i<20;i++) {
        
    			if(i>=10) {
        
    				return a;
    			}
    			System.out.println(Thread.currentThread().getName()+i);
    		}
    		return null;
    	}
    
    }
    
    
    
    package thread_callable;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    /**
     * 使用Callable接口和FutureTask实现多线程
     * 步骤：
     * 1.创建Callable接口实现类
     * 2.重写接口的call()方法
     * 3.构造实现类的对象
     * 4.利用FutureTask类构造一个线程的任务
     * 5.将线程任务构造进Thread
     * 6.调用start()开启一个线程
     * @author DELL
     *
     */
    public class callableTest {
        
    	public static void main(String[] args) {
        
    		callableimpl cab=new callableimpl();
    		FutureTask<Integer> fu=new FutureTask<Integer>(cab);
    		Thread th=new Thread(fu);
    		th.start();
    		for(int i=0;i<20;i++) {
        
    			System.out.println(Thread.currentThread().getName()+i);
    		}
    		try {
        
    			System.out.println("计算结果是："+fu.get());
    		} catch (InterruptedException | ExecutionException e) {
        
    			e.printStackTrace();
    		}
    	}
    	
    }