java 大量进程 java多进程怎么实现的

转载

mob6454cc63081f 2023-07-18 17:55:40

文章标签 java 大量进程多线程 java System 文章分类 Java 后端开发

一、进程与线程

进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。

线程：是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。

二、什么是多线程

多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

三、java中如何实现多线程

继承Thread类实现多线程，重写run()方法，使用start()方法开启多线程（JDK 1.0 时提出）

package base.Multithreading;

public class FromThread{
	public static void main(String[] args) {
    	MyThread a = new MyThread("A");
    	MyThread b = new MyThread("B");
    	MyThread c = new MyThread("C");

    	a.start();
    	b.start();
    	c.start();
	}
}

class MyThread extends Thread{

	String name;

	MyThread(String name){
    	this.name = name;
	}

	@Override
	public void run() {
    	for(int i = 0 ; i < 10 ;i++){
        	System.out.println("Thread " + name + " is running.....");
    	}
	}
}

如果一个线程启动了很多次，那么将会抛出java.lang.IllegalThreadStateException异常

实现Runnable接口实现多线程（JDK 1.0 时提出）
将实现了Runnable的类封装到Thread类中，使用Thread的实例调用start()方法开启线程

package base.Multithreading;

public class FromRunable {
	public static void main(String[] args) {
    	Thread a = new Thread(new MyThread1("A"));
    	Thread b = new Thread(new MyThread1("B"));
    	Thread c = new Thread(new MyThread1("C"));

    	a.start();
    	b.start();
    	c.start();
	}
}

class MyThread1 implements Runnable{
	String name;

	MyThread1(String name){
    	this.name = name;
	}


	@Override
	public void run() {
    	for (int i = 0 ; i < 10 ; i++){
        	System.out.println("Thread " + name + " is running...");
    	}
	}
}

实现Callable（java.util.concurrent）接口实现多线程（JDK 1.5 时提出）
Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。

示例：

package base.Multithreading;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FromCallable {
	public static void main(String[] args) throws ExecutionException, InterruptedException {
    	// 使用 FutureTask 的实例包裹线程类对象
    	FutureTask<String> futureTask = new FutureTask<>(new MyThread2("A"));

    	// 使用 FutureTask 的实例包裹线程类对象
    	FutureTask<String> futureTask1 = new FutureTask<>(new MyThread2("B"));

    	// 使用 FutureTask 的实例包裹线程类对象
    	FutureTask<String> futureTask2 = new FutureTask<>(new MyThread2("C"));



    	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
    	new Thread(futureTask).start();

    	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
    	new Thread(futureTask1).start();

    	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
    	new Thread(futureTask2).start();



    	// 使用 futureTask.get() 会抛出异常
    	System.out.println(futureTask.get());

    	// 使用 futureTask.get() 会抛出异常
    	System.out.println(futureTask1.get());

    	// 使用 futureTask.get() 会抛出异常
    	System.out.println(futureTask2.get());
	}
}

class MyThread2 implements Callable<String> {
	String name;

	MyThread2(String name){
    	this.name = name;
	}


	@Override
	public String call() throws Exception {
    	for(int i = 0; i < 10 ; i++){
        	System.out.println("Thread " + name + " is running...");
    	}
    	return "线程执行结束...";
	}
}