Java之进程与线程

向右看齐 2023-02-28 11:27 50阅读 0赞

## 进程 ##

一个正在执行中的程序  
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元

## 线程 ##

进程中的一个独立的控制单元  
线程在控制着进程的执行

> 一个进程中至少有一个线程

Java VM启动的时候会有一个进程java.exe  
该进程中至少一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

> 扩展：更细致说jvm启动不止一个线程，还有负责垃圾回收机制的线程。

## 多线程存在的意义 ##

提升了效率

## 多线程的特性 ##

**随机性**  
在某一时刻，只能有一个程序在运行（多核除外），cpu在进行着快速的切换，以达到看上去是同时运行的效果。至于每个线程运行多长时间，由cpu决定。

## 线程中的常用方法 ##

获取当前线程对象：static Thread currentThread()  
设置线程名称：setName或者构造函数(super(name))  
获取线程名称：getName  
设置线程休眠：static Thread sleep 需要处理异常

try{ Thread.sleep(10);}catch(Exception e){ }

## 创建线程 ##

**创建方式一（继承Thread类）**

1.  继承Thread类
2.  子类覆盖父类中的run方法，run方法相当于一个存储器，存储着线程要运行的代码
3.  建立Thread子类对象的同时线程也被创建。
4.  调用start方法，开启线程并运行run方法。

**代码实例**

class ZiThread extends Thread{ 
    	public void run(){ 
    		for(int i = 0; i < 50; i++){ 
    			System.out.println(Thread.currentThread()+"---zi run---"+this.getName()+"---"+i);
    		}
    	}
    }
    class ThreadDemo{ 
    	public static void main(String[] args) { 
    		ZiThread d = new ZiThread();//创建Thread子类对象则创建了一个线程
    		d.start();//启动线程并运行run方法
    		//d.run();//只是调用了run方法，线程创建了并没有运行
    		for(int i = 0; i < 50; i++){ 
    			System.out.println("main---"+i);
    		}
    	}
    }

**运行结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]**创建方式二（实现Runable接口）**

1.  定义类实现Runable接口
2.  覆盖Runable接口中的run方法，存放线程要运行的代码
3.  通过Thread类建立线程对象
4.  将Runable接口的子类对象作为实际参数传递给Thread类的构造函数，让线程去指定指定对象的run方法，方便运行的时候执行
5.  调用Thread类的start方法开启线程并调用Runable接口子类的run方法

**代码实例**

class Ticket implements Runnable{ 
    	int num = 100;//多线程共享数据
    	public void run(){ 
    		while(num>0){ 
    			System.out.println(Thread.currentThread().getName() + "run ......" + num--);
    		}
    	}
    }
    class RunableDemo{ 
    	public static void main(String[] args) { 
    		Ticket t = new Ticket();
    		Thread t1 = new Thread(t);//创建线程
    		Thread t2 = new Thread(t);//创建线程
    		t1.start();
    		t2.start();
    	}
    }

**运行结果**  
![在这里插入图片描述][20200723131602556.png]

## 两种创建线程的区别 ##

**继承方式**  
继承了Thread类之后，就不能继承其他类。  
线程代码存放在子类的run方法中。  
**实现方式**  
避免了单继承的局限性，建议使用。  
线程代码存放在接口子类的run方法中  
可以共用成员变量

## 多线程运行安全问题 ##

**问题原因**

*  多个线程访问出现延迟
 *  线程随机性

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。另一个线程就已经参与进来运行，导致共享数据出现错误。  
**解决方法**  
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不允许参与进来。  
采用同步（锁）的方式实现。  
**同步代码块**

synchronized(对象){ 
    	需要被同步的代码
    }

对象如同锁，持有锁的线程可以在同步中执行。  
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

代码实例，改变上面的代码

class Ticket implements Runnable{ 
    	int num = 100;
    	Object obj = new Object();
    	public void run(){ 
    		while(true){ 
    			synchronized(obj){ //同步代码块
    				if(num>0){ 
    					try{ Thread.sleep(10);}catch(Exception e){ }
    					System.out.println(Thread.currentThread().getName() + "run ......" + num--);
    				}
    			}
    		}
    	}
    }

**同步函数**  
在函数上加入synchronized修饰符，同步函数使用的锁是this  
如果同步函数被静态修饰符修饰后，使用的锁不再是this，而是该方法所在类的字节码文件对象，类名.class

静态类进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class，该对象的类型是Class。

class Ticket implements Runnable{ 
    	static int num = 100;
    	boolean flag = true;
    	Object obj = new Object();
    	public void run(){ 
    		if(flag){ 
    			while(true){ 
    				synchronized(Ticket.class){ 
    					if(num>0){ 
    						try{ Thread.sleep(10);}catch(Exception e){ }
    						System.out.println(Thread.currentThread().getName() + "......code ......" + num--);
    					}
    				}
    			}	
    		}
    		else
    			show();
    	}
    	public static synchronized void show(){ 
    		if(num>0){ 
    			try{ Thread.sleep(10);}catch(Exception e){ }
    			System.out.println(Thread.currentThread().getName() + "....... show ......" + num--);
    		}
    	}
    }
    class RunableDemo{ 
    	public static void main(String[] args) { 
    		Ticket t = new Ticket();
    		Thread t1 = new Thread(t);//创建线程
    		Thread t2 = new Thread(t);
    		t1.start();
    		try{ Thread.sleep(10);}catch(Exception e){ }
    		t.flag = false;
    		t2.start();
    	}
    }

**同步的前提**

1.  必须要有两个或两个以上的线程
2.  必须是多个线程使用同一个锁

**同步的好处**  
解决了多线程的安全问题  
**同步的弊端**  
当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。  
**死锁**  
同步中嵌套同步

class Ticket implements Runnable{ 
    	int num = 100;
    	boolean flag = true;
    	Object obj = new Object();
    	public void run(){ 
    		if(flag){ 
    			while(true){ 
    				synchronized(obj){ //obj锁
    					show();
    				}	
    			}	
    		}
    		else
    			show();
    	}
    	public synchronized void show(){ //this锁
    		synchronized(obj){ //obj锁
    			if(num>0){ 
    				try{ Thread.sleep(10);}catch(Exception e){ }
    				System.out.println(Thread.currentThread().getName() + "......code ......" + num--);
    			}
    		}
    	}
    }
    class RunableDemo{ 
    	public static void main(String[] args) { 
    		Ticket t = new Ticket();
    		Thread t1 = new Thread(t);//创建线程
    		Thread t2 = new Thread(t);
    		t1.start();
    		try{ Thread.sleep(10);}catch(Exception e){ }
    		t.flag = false;
    		t2.start();
    	}
    }

**等待唤醒机制（线程间通信）**  
wait()、notify()、notifyAll()  
必须放在同步中  
必须要标识所属的同步的锁  
属于Object类的方法，锁可以是任意对象  
实例：

class Resource{ 
    	String name;
    	String sex;
    	Boolean flag = false; 
    }
    //写入
    class Input implements Runnable{ 
    	private Resource r;
    	Input(Resource r){ //确保操作的是同一对象
    		this.r = r;
    	}
    	public void run(){ 
    		int x = 0;
    		while(true){ 
    			synchronized(r){ //确保操作同一个锁
    				if(r.flag)
    					try{ r.wait();}catch(Exception e){ }//等待
    				if(x==0){ 
    					r.name = "star";
    					r.sex = "man";
    				}else{ 
    					r.name = "逸筱";
    					r.sex = "女";
    				}
    				x = (x + 1)%2;
    				r.flag = true;
    				r.notify();//唤醒线程空间中第一个
    			}
    		}
    	}
    }
    //输出
    class Output implements Runnable{ 
    	private Resource r;
    	Output(Resource r){ 
    		this.r = r;
    	}
    	public void run(){ 
    		while(true){ 
    			synchronized(r){ 
    				if(!r.flag)
    					try{ r.wait();}catch(Exception e){ }	
    				System.out.println(r.name+"......"+r.sex);
    				r.flag = false;
    				r.notify();
    			}
    		}
    	}
    }
    class WaitNotifyDemo{ 
    	public static void main(String[] args) { 
    		Resource r = new Resource();
    		Input input = new Input(r);
    		Output output = new Output(r);
    		//创建线程
    		Thread t1 = new Thread(input);
    		Thread t2 = new Thread(output);
    		//启动线程
    		t1.start();
    		t2.start();
    	}
    }

效果：  
![在这里插入图片描述][20200727152655498.png]  
**生产消费模式**  
生产一个，消费一个，多个线程同时运行  
对于多个生产者和消费者，注意：

> 需要用while判断标记，让被唤醒的线程再一次去进行标记判断，以免唤醒之后直接向下执行，出现生产多个消费一个的情况。  
> 需要定义notifyAll唤醒对方线程。只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。

class Resource{ 
    	private String name;
    	private int count = 0;
    	private Boolean flag = false;
    	public synchronized void set(String name){ //t1 t2
    		while(flag)//线程被唤醒之后，接着进行判断，否则会直接进行下面的逻辑
    			try{ wait();}catch(Exception e){ }	
    		this.name = name + "---" + count++;
    		System.out.println(Thread.currentThread().getName() + "-生产-" + this.name);
    		flag = true;
    		this.notifyAll();//唤醒对方，释放线程池中的所有,防止所有线程都进入等待状态
    	}
    	public synchronized void out(){ //t3 t4
    		while(!flag)
    			try{ wait();}catch(Exception e){ }	
    		System.out.println(Thread.currentThread().getName() + "---消费---" + this.name);
    		flag = false;
    		this.notifyAll();	
    	}
    }
    class Producer implements Runnable{ //生产者
    	private Resource r;
    	Producer(Resource r){ 
    		this.r = r;
    	} 
    	public void run(){ 
    		while(true)
    			r.set("逸筱");
    	}
    }
    class Consumer implements Runnable{ //消费者
    	private Resource r;
    	Consumer(Resource r){ 
    		this.r = r;
    	} 
    	public void run(){ 
    		while(true)
    			r.out();
    	}
    }
    class WaitNotifyAll{ 
    	public static void main(String[] args) { 
    		Resource r = new Resource();
    		Producer pro = new Producer(r);//确保操作同一个对象
    		Consumer con = new Consumer(r);
    		Thread t1 = new Thread(pro);
    		Thread t2 = new Thread(pro);
    		Thread t3 = new Thread(con);
    		Thread t4 = new Thread(con);
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();
    	}
    }

效果：  
![在这里插入图片描述][2020072914160060.png]  
**Lock**  
jdk1.5之后新增了Lock  
同步Synchronized替换成显示Lock操作  
将Object中的wait，notify，notifyAll替换为Condition对象  
可以实现本方只唤醒对方操作

import java.util.concurrent.locks.*;
    class Resource{ 
    	private String name;
    	private int count = 0;
    	private boolean flag = false;
    	private Lock lock = new ReentrantLock();
    	private Condition condition_pro = lock.newCondition();//生产对象
    	private Condition condition_con = lock.newCondition();//消费对象
    	public void set(String name) throws InterruptedException
    	{ 
    		lock.lock();//上锁，相当于Synchronized同步操作
    		try{ 
    			while(flag)
    				condition_pro.await();//本方进入等待状态
    			this.name = name + "---" + count++;
    			System.out.println(Thread.currentThread().getName()+"-生产者-"+this.name);
    			flag = true;
    			condition_con.signal();//唤醒消费方
    		}finally{ 
    			lock.unlock();//释放锁
    		}
    	}
    	public void out() throws InterruptedException
    	{ 
    		lock.lock();
    		try{ 
    			while(!flag)
    				condition_con.await();//本方进入等待状态
    			System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
    			flag = false;
    			condition_pro.signal();//唤醒生产方
    		}finally{ 
    			lock.unlock();//释放锁
    		}
    	}
    }
    class Producer implements Runnable{ 
    	private Resource r;
    	Producer(Resource r){ 
    		this.r = r;
    	}
    	public void run(){ 
    		while(true){ 
    			try{ 
    				r.set("逸轩");
    			}catch(InterruptedException e){ 
    
    			}
    		}	
    	}
    }
    class Consumer implements Runnable{ 
    	private Resource r;
    	Consumer(Resource r){ 
    		this.r = r;
    	}
    	public void run(){ 
    		while(true){ 
    			try{ 
    				r.out();
    			}catch(InterruptedException e){ 
    
    			}
    		}
    	}
    }
    class LockDemo{ 
    	public static void main(String[] args) { 
    		Resource r = new Resource();
    		Producer pro = new Producer(r);
    		Consumer con = new Consumer(r);
    		Thread t1 = new Thread(pro);
    		Thread t2 = new Thread(pro);
    		Thread t3 = new Thread(con);
    		Thread t4 = new Thread(con);
    		t1.start();
    		t2.start();
    		t3.start();
    		t4.start();
    	}
    }

效果：  
![在这里插入图片描述][20200729163318845.png]  
**wait()和sleep()的区别**  
wait()：释放CPU执行权，释放锁  
sleep()：释放CPU执行权，不释放锁

**停止线程**

> stop()方法已过时

停止线程的方法只有一种，即run方法结束。  
开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，即让线程结束。

1.  定义循环结束标记
    
    特殊状态：当线程处于了冻结状态，将不会再去读取结束线程的标记，线程将不会结束。
2.  使用interrupt（中断）方法  
    刚方法是结束线程的冻结状态，使线程回到运行状态中来。

实例

class StopThread implements Runnable{ 
    	private boolean flag = true;
    	public synchronized void run(){ 
    		while(flag){ 
    			try{ 
    				wait();
    			}catch(InterruptedException e){ 
    				System.out.println(Thread.currentThread().toString()+"---Exception");
    				flag = false;
    			}
    			System.out.println(Thread.currentThread().toString()+"---run");
    		}
    	}
    	public void changeStatus(){ 
    		flag = false;
    	}
    }
    class StopThreadDemo{ 
    	public static void main(String[] args) { 
    		StopThread st = new StopThread();
    		Thread t1 = new Thread(st);
    		t1.start();
    		int num = 0;
    		while(true){ 
    			if(num == 30){ 
    				t1.interrupt();
    				break;
    			}
    			System.out.println("main"+"---"+num);
    			num += 1;
    		}
    	}
    }

**守护线程**  
new Thread().setDaemon(true)  
依赖线程结束，当前线程自动结束。当正在运行的线程都是守护线程时，Java虚拟机退出  
实例：

class StopThread implements Runnable{ 
    	private boolean flag = true;
    	public void run(){ 
    		while(flag){ 
    			System.out.println(Thread.currentThread().toString()+"---run");
    		}
    	}
    }
    class StopThreadDemo{ 
    	public static void main(String[] args) { 
    		StopThread st = new StopThread();
    		Thread t1 = new Thread(st);
    		//主线程结束，则只剩下t1守护线程，虚拟机会自动退出
    		t1.setDaemon(true);
    		t1.start();
    		int num = 0;
    		while(true){ 
    			if(num == 30){ 
    				break;
    			}
    			System.out.println("main"+"---"+num);
    			num += 1;
    		}
    	}
    }

结果：  
![在这里插入图片描述][20200731122119309.png]  
**join**  
临时加入线程，索要CPU执行权，主线程碰到join方法，释放执行权，等该线程结束，主线程恢复  
实例：

class StopThread implements Runnable{ 
    	private boolean flag = true;
    	private int num = 0;
    	public void run(){ 
    		while(num<30){ 
    			System.out.println(Thread.currentThread().toString()+"---run");
    			num++;
    		}
    	}
    }
    class StopThreadDemo{ 
    	public static void main(String[] args) throws Exception
    	{ 
    		StopThread st = new StopThread();
    		Thread t1 = new Thread(st);
    		Thread t2 = new Thread(st);
    		t1.start();
    		t1.join();//下面的线程暂时释放执行权，t1结束，其他恢复
    		t2.start();
    		int num = 0;
    		while(true){ 
    			if(num == 30){ 
    				break;
    			}
    			System.out.println("main"+"---"+num);
    			num += 1;
    		}
    	}
    }

结果：  
![在这里插入图片描述][20200731123709526.png]  
**toString**  
返回该线程的字符串表现形式，包括线程名称、优先级（总共1-10，默认为5）和线程组  
更改线程的优先级 setPriority(int newPriority)  
最高优先级MAX\_PRIORITY 10  
最低优先级MIN\_PRIORITY 1  
默认优先级NORM\_PRIORITY 5  
使用：new Thread().setPriority(Thread.MAX\_PRIORITY);  
**yield**  
暂停当前正在执行的线程对象，执行其他线程  
**匿名内部类使用**

class StopThreadDemo{ 
    	public static void main(String[] args)
    	{ 
    		new Thread(){ 
    			public void run(){ 
    				for(int x = 0; x < 30; x++){ 
    					System.out.println(Thread.currentThread().getName()+"---"+x);
    				}
    			}
    		}.start();
    		for(int x = 0; x < 30; x++){ 
    			System.out.println(Thread.currentThread().getName()+"---"+x);
    		}
    		Runnable t1 = new Runnable(){ 
    			public void run(){ 
    				for(int x = 0; x < 30; x++){ 
    					System.out.println(Thread.currentThread().getName()+"---"+x);
    				}
    			}
    		};
    		new Thread(t1).start();
    	}
    }

## 线程的六种状态 ##

java线程状态在Thread中定义，源码中能看到有个枚举State，总共定义了六种状态：

1.  NEW：新建状态，线程对象已经创建，但尚未启动
2.  RUNNABLE：就绪状态，可运行状态，调用了线程的start方法，已经在java虚拟机中执行，等待获取操作系统资源如CPU，操作系统调度运行。
3.  BLOCKED：堵塞状态。线程等待锁的状态，等待获取锁进入同步块/方法或调用wait后重新进入需要竞争锁
4.  WAITING：等待状态。等待另一个线程以执行特定的操作。调用以下方法进入等待状态。 Object.wait(),Thread.join(),LockSupport.park
5.  TIMED\_WAITING：线程等待一段时间。调用带参数的Thread.sleep,  
    objct.wait,Thread.join，LockSupport.parkNanos,LockSupport.parkUntil
6.  TERMINATED:进程结束状态。

状态之间的转换状态图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 1]其中，Thread.sleep(long)使线程暂停一段时间，进入TIMED\_WAITING时间，并**不会释放锁**，在设定时间到或被interrupt后抛出，InterruptedException后进入RUNNABLE状态； Thread.join是等待调用join方法的线程执行一段时间(join(long))或结束后再往后执行，被interrupt后也会抛出异常，join内部也是wait方式实现的。

wait方法是object的方法，**线程释放锁**，进入WAITING或TIMED\_WAITING状态。等待时间到了或被notify/notifyall唤醒后，回去竞争锁，如果获得锁，进入RUNNABLE，否则进步BLOCKED状态等待获取锁。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]: /images/20230209/6b42974ed1ae481aa3aab2864962e880.png
[20200723131602556.png]: https://img-blog.csdnimg.cn/20200723131602556.png
[20200727152655498.png]: https://img-blog.csdnimg.cn/20200727152655498.png
[2020072914160060.png]: https://img-blog.csdnimg.cn/2020072914160060.png
[20200729163318845.png]: https://img-blog.csdnimg.cn/20200729163318845.png
[20200731122119309.png]: https://img-blog.csdnimg.cn/20200731122119309.png
[20200731123709526.png]: https://img-blog.csdnimg.cn/20200731123709526.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200721150057850.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw==,size_16,color_FFFFFF,t_70