java进程控制 java 进程管理

转载

AI独步天下 2023-07-11 14:23:40

文章标签 java进程控制多线程 java 操作系统 System 文章分类 Java 后端开发

文章目录

1、多进程和多线程
2、java中多线程的实现

2.1 Thread类实现
2.2 runnable接口实现

3、java中多线程信息共享
4、java中多线程管理

4.1 线程状态
4.2 线程协作
4.3 死锁问题
4.4 后台线程
4.5 线程组管理

总结

1、多进程和多线程

进程定义：进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

怎么理解呢？进程就是程序的一次执行过程。比如：java中main函数执行一次呀。QQ、网易云、mysql等在运行呀之类的。

线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。一个程序包含多个子任务，每个子任务可以称为一个线程，如果一个子任务阻塞,程序可以将CPU调度另外一个子任务进行工作这样CPU还是保留在本程序中,而不是被调度到别的程序(进程)去这样,提高本程序所获得CPU时间和利用率。

线程可以理解为同一个程序不同模块:程序会出现多段代码分开执行的。多线程在通讯和协调上具有更大的优势。

进程与线程区别：

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
资源分配给进程，同一进程的所有线程共享该进程的所有资源。
CPU分给线程，即真正在CPU上运行的是线程。

并行、串行、并发
并行：多个CPU，每个线程分配给独立的核心，线程同步运行。

串行：单个CPU，执行完一个再执行另一个。

并发：多个线程在单个CPU上运行，同一时间一个线程运行，系统不停切换线程，看起来多个线程并行，实际上是线程不停切换。

异步与同步
在io等待的时候，同步不会切走，浪费了时间。
同步，是所有的操作都做完，才返回给用户结果。即写完数据库之后，再响应用户，用户体验不好。
异步，不用等所有操作都做完，就相应用户请求。即先响应用户请求，然后慢慢去写数据库，用户体验较好。

2、java中多线程的实现

2.1 Thread类实现

线程需要继承Thread类，实现run方法。

注意，使用start方法，程序会自动以新进程调用run方法，直接调用run方法会变成串行执行。

线程无需关闭，在run方法执行结束后会自动关闭，main函数可能早于新线程结束，程序并不终止。程序终止是等所有线程都终止。

上个简单的代码：

public class ThreadDemo1
{
	public static void main(String args[]) throws Exception
	{
		new TestThread1().start();
		while(true)
		{
			System.out.println("main thread is running");
			Thread.sleep(1000);
		}
	}
}

class TestThread1 extends Thread
{
	public void run() 
	{
		while(true)
		{
			System.out.println(" TestThread1 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

2.2 runnable接口实现

线程需要实现Runnable接口，实现run方法。一般使用实现接口的方式来实现多线程，因为java只能单继承，继承了Thread类就不能继承其他的类了，用实现接口的方式不会出现这种问题。

注意runnable接口实现的类需要将其作为参数构建Thread类再使用start方法。同一个线程类多次start会报错，其启动的先后顺序是随机的。

上个简单的代码：

public class ThreadDemo3
{
	public static void main(String args[])
	{
		TestThread3 tt= new TestThread3();
		Thread t= new Thread(tt);
		t.start();
		while(true)
		{
			System.out.println("main thread is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
class TestThread3 implements Runnable //extends Thread
{
	public void run()
	{
		while(true)
		{
			System.out.println(Thread.currentThread().getName() +
			" is running");
			try {
				Thread.sleep(1000); 
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

3、java中多线程信息共享

子线程与子线程，子线程与主线程之间需要进行交流。多线程是为了加快程序运行速度，但是不同线程之间可能会访问一些相同的资源，需要构建线程之间信息交流通讯。

java多线程中是通过共享变量达到信息共享。

传统方案，采用普通的共享变量：

继承Thread类时，基于static变量。
同一个Runnable类的成员变量

上述方案是不行的。

原因：

java进程控制 java 进程管理_java

1、每个线程都有一个工作缓存。

线程执行过程是：

读取主存内容（正本）到工作缓存（副本）中
每个CPU执行（副本）的操作，生成结果
CPU将结果写入到缓存（副本）中
数据从工作缓存（副本）刷到主存（正本）中。

所以能理解为啥传统共享变量方法不行了，从主存拿数据时拿的是一样的，但在缓存中进行数据操作之后，没法告知其他线程，原来的变量已经发生了改变。

2、多个线程对同一变量进行操作缺乏加锁限制。一窝蜂都对同一个变量进行操作，就会出错。

解决方法：

java中提供了两个关键字解决上述两个问题：

1、volatile：一旦一个变量在子线程工作缓存中修改了，其他线程也能够获取最新值。用来修饰关键字，保证不同线程对共享变量操作时的可见性。
2、synchronized：用来修饰代码块/函数，一次只能让一个线程进入，虽然加大了性能负担，但是使用简便。

举个例子：

public class ThreadDemo3 {
	public static void main(String[] args) {
		TestThread3 t = new TestThread3();
		//包装为Thread类，并且传入线程名
		new Thread(t, "Thread-0").start();
		new Thread(t, "Thread-1").start();
		new Thread(t, "Thread-2").start();
		new Thread(t, "Thread-3").start();
	}
}

class TestThread3 implements Runnable {
	private volatile int tickets = 100; // 用volatile修饰，保证不同线程对共享变量操作时的可见性。
	String str = new String("");

	public void run() {
		while (true) {
			sale();
			try {
				Thread.sleep(100);
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
			if (tickets <= 0) {
				break;
			}
		}
	}

	public synchronized void sale() { // ͬsynchronized修饰，互斥。
		if (tickets > 0) {
			System.out.println(Thread.currentThread().getName() + " is saling ticket " + tickets--);
		}
	}
}

4、java中多线程管理

4.1 线程状态

java进程控制 java 进程管理_System_02

线程状态有：

new：刚创建（new）
runnable：就绪状态（start）
running：运行中（run）
block：阻塞状态（sleep）
terminaled：结束

4.2 线程协作

线程阻塞和唤醒

sleep。设置线程阻塞的时间，时间到了会自动醒过来。
wait/notify/notifyAll。等待，知道别人唤醒。
join。等待另一个线程结束。
interrupt。向另外一个线程发送中断信号,该线程收到信号,会触发InterruptedException(可解除阻塞)，并进行下一步处理。向别人发送一个信号，告诉别人，你可以停止了。需要自己去写异常处理，被动结束，可能来不及释放资源。建议采用定期检测共享变量，优雅的释放资源。

举个例子：生产者和消费者问题

* 经典生产者与消费者问题
 * 生产者不断的往仓库中存放产品，消费者从仓库中消费产品。
 * 其中生产者和消费者都可以有若干个。
 * 仓库规则：容量有限，库满时不能存放，库空时不能取产品 。

贴代码：

package product;
/**
 * 经典生产者与消费者问题
 * 生产者不断的往仓库中存放产品，消费者从仓库中消费产品。
 * 其中生产者和消费者都可以有若干个。
 * 仓库规则：容量有限，库满时不能存放，库空时不能取产品 。
 */

public class ProductTest {
	public static void main(String[] args) throws InterruptedException {
		Storage storage = new Storage();
		
		Thread consumer1 = new Thread(new Consumer(storage));
		consumer1.setName("消费者1");
		Thread consumer2 = new Thread(new Consumer(storage));
		consumer2.setName("消费者2");
		Thread producer1 = new Thread(new Producer(storage));
		producer1.setName("生产者1");
		Thread producer2 = new Thread(new Producer(storage));
		producer2.setName("生产者2");
		
		producer1.start();
		producer2.start();
		Thread.sleep(1000);		
		consumer1.start();
		consumer2.start();		
	}
}

package product;

/**
 *仓库
 */
class Storage {
	// 仓库容量为10
	private Product[] products = new Product[10];
	private int top = 0;

	// 生产者往仓库中放入产品
	public synchronized void push(Product product) {
		while (top == products.length) {
			try {
				System.out.println("producer wait");
				wait();//仓库已满，等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
        //把产品放入仓库
		products[top++] = product;
		System.out.println(Thread.currentThread().getName() + " 生产了产品"
				+ product);
		System.out.println("producer notifyAll");
		notifyAll();//唤醒等待线程
		

	}

	// 消费者从仓库中取出产品
	public synchronized Product pop() {
		while (top == 0) {
			try {
				System.out.println("consumer wait");
				wait();//仓库空，等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

		//从仓库中取产品
		--top;
		Product p = new Product(products[top].getId(), products[top].getName());
		products[top] = null;
		System.out.println(Thread.currentThread().getName() + " 消费了产品" + p);
		System.out.println("comsumer notifyAll");
		notifyAll();//唤醒等待线程
		return p;
	}
}

package product;

import java.util.Random;

/**
 * 生产者
 */
class Producer implements Runnable {
	private Storage storage;

	public Producer(Storage storage) {
		this.storage = storage;
	}

	@Override
	public void run() {
		int i = 0;
		Random r = new Random();
		while(i<10)
		{
			i++;
			Product product = new Product(i, "电话" + r.nextInt(100));
			storage.push(product);
		}		
	}
}

package product;

/**
 * 消费者
 */
class Consumer implements Runnable {
	private Storage storage;

	public Consumer(Storage storage) {
		this.storage = storage;
	}

	public void run() {
		int i = 0;
		while(i<10)
		{
			i++;
			storage.pop();
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}
}

package product;

/**
 * 产品类
 */
class Product {
	private int id;// 产品id
	private String name;// 产品名称

	public Product(int id, String name) {
		this.id = id;
		this.name = name;
	}
	public String toString() {
		return "(产品ID：" + id + " 产品名称：" + name + ")";
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

简单理解上面的内容就是：

两个生产者都开始生产，各生产10个产品。仓库只能存10个，存满了就等待，如果被消费了，就唤醒所有的生产线程。
两个消费者都开始消费，各消费10个产品。仓库产品为0个，就开始等待，如果有新的产品来了，就唤醒所有线程。

这个例子呢，其实还没有完全解释清楚notifyAll和notify怎么用的。但是这个经典的例子还是给人很多启发。包括怎么设计这种仓库存储的并发结构，经典的东西还是很值得学习。（种个草，之后写一期详解这些函数的blog哈）

再举个例子：使用interrupt暴力结束进程

package interrupt;

public class InterruptTest {

	public static void main(String[] args) throws InterruptedException {
		TestThread1 t1 = new TestThread1();
		TestThread2 t2 = new TestThread2();

		t1.start();
		t2.start();

		// 让线程运行一会儿后中断
		Thread.sleep(2000);
		t1.interrupt();
		t2.flag = false;
		System.out.println("main thread is exiting");
	}

}

class TestThread1 extends Thread {
	public void run() {
		// 判断标志，当本线程被别人interrupt后，JVM会被本线程设置interrupted标记
		while (!interrupted()) {
			System.out.println("test thread1 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
				break;
			}
		}
		System.out.println("test thread1 is exiting");
	}
}

class TestThread2 extends Thread {
	public volatile boolean flag = true;
	public void run() {
		// 判断标志，当本线程被别人interrupt后，JVM会被本线程设置interrupted标记
		while (flag) {
			System.out.println("test thread2 is running");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("test thread2 is exiting");
	}
}

使用interrupt来打断线程，需要自己去写异常处理，被动结束，可能来不及释放资源。建议采用定期检测共享变量，优雅的释放资源。

4.3 死锁问题

为啥会出现死锁呢？

每个线程互相持有别人需要的锁。
预防死锁，对资源进行等级排序。

举个例子：

package deadlock;
import java.util.concurrent.TimeUnit;

public class ThreadDemo5
{
	public static Integer r1 = 1;
	public static Integer r2 = 2;
	public static void main(String args[]) throws InterruptedException
	{
		TestThread51 t1 = new TestThread51();
		t1.start();
		TestThread52 t2 = new TestThread52();
		t2.start();
	}
}
class TestThread51 extends Thread
{
	public void run() 
	{
		//先要r1,再要r2
		synchronized(ThreadDemo5.r1)
		{
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(ThreadDemo5.r2)
			{
				System.out.println("TestThread51 is running");
			}
		}
	}
} 
class TestThread52 extends Thread
{
	public void run() 
	{
		//先要r2,再要r1
		synchronized(ThreadDemo5.r1)
		{
			try {
				TimeUnit.SECONDS.sleep(3);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized(ThreadDemo5.r2)
			{
				System.out.println("TestThread52 is running");
			}
		}
	}
}

java进程控制 java 进程管理_System_03

查看线程状态：cmd中输入jvisualvm。

4.4 后台线程

普通线程，run方法运行结束之后才结束
守护线程，run方法运行结束或者main函数结束。

package daemon;

public class ThreadDemo4
{
	public static void main(String args[]) throws InterruptedException
	{
		TestThread4 t = new TestThread4();
		t.setDaemon(true);
		t.start();
		Thread.sleep(2000);
		System.out.println("main thread is exiting");
	}
}
 class TestThread4 extends Thread
{
	public void run() 
	{
		while(true)
		{
			System.out.println("TestThread4" + 
			"��is running");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

守护线程永远不要访问资源，如文件或者数据库等，可能会被动结束，来不及去释放这些资源。

4.5 线程组管理

有多个Thread时，怎么把它放在一起进行管理。
缺点：

能够有效管理多个线程，但是管理效率低。
任务分配和执行过程高度耦合。
重复创建线程，关闭线程操作，无法重用线程。

package threadgroup;

import java.util.concurrent.TimeUnit;

public class Main {

	public static void main(String[] args) {

		// 创建线程组
		ThreadGroup threadGroup = new ThreadGroup("Searcher");
		Result result=new Result();

		// 创建一个任务，10个线程完成
		Searcher searchTask=new Searcher(result);
		for (int i=0; i<10; i++) {
			Thread thread=new Thread(threadGroup, searchTask);
			thread.start();
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("========华丽丽0=======");
		
		// 查看线程组消息
		System.out.printf("active 线程数量: %d\n",threadGroup.activeCount());
		System.out.printf("线程组信息明细\n");
		threadGroup.list();
		System.out.println("========华丽丽1=======");

		// 遍历线程组
		Thread[] threads=new Thread[threadGroup.activeCount()];
		threadGroup.enumerate(threads);
		for (int i=0; i<threadGroup.activeCount(); i++) {
			System.out.printf("Thread %s: %s\n",threads[i].getName(),threads[i].getState());
		}
		System.out.println("========华丽丽2=======");

		// Wait for the finalization of the Threadds
		waitFinish(threadGroup);
		
		// Interrupt all the Thread objects assigned to the ThreadGroup
		threadGroup.interrupt();
	}

	public static void waitFinish(ThreadGroup threadGroup) {
		while (threadGroup.activeCount()>9) {
			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package threadgroup;

import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class Searcher implements Runnable {

	private Result result;
	
	public Searcher(Result result) {
		this.result=result;
	}

	@Override
	public void run() {
		String name=Thread.currentThread().getName();
		System.out.printf("Thread %s: 启动\n",name);
		try {
			doTask();
			result.setName(name);
		} catch (InterruptedException e) {
			System.out.printf("Thread %s: 被中断\n",name);
			return;
		}
		System.out.printf("Thread %s: 完成\n",name);
	}
	
	private void doTask() throws InterruptedException {
		Random random=new Random((new Date()).getTime());
		int value=(int)(random.nextDouble()*100);
		System.out.printf("Thread %s: %d\n",Thread.currentThread().getName(),value);
		TimeUnit.SECONDS.sleep(value);
	}
}

package threadgroup;

/**
 * 搜索结果类
 *
 */
public class Result {
	
	private String name;	
	public String getName() {
		return name;
	}	
	public void setName(String name) {
		this.name = name;
	}

}

java进程控制 java 进程管理_操作系统_04

这个不是主流的啦，先不详细看了。

总结

纯粹学习记录

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：网络安全网格架构(CSMA) 网络安全框架csf

下一篇：fastapi python 接口demo python flask 写接口

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯