学到牙痛之线程

港控/mmm° 2022-03-25 04:22 199阅读 0赞

# 一 瞎扯 #

![20190118164109166.png][]

看看电影再来学习。

推荐：[进程与线程的一个简单解释][Link 1]

## 1 多道程序设计 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

现代操作系统中，能同时运行多个程序。可以一边打开浏览器看小片片，一边打开微信瞎聊，一边用idea写程序......启动一个浏览器，就相当于在运行一个进程，启动微信和 idea 同理。

## 2 并发环境与并发程序 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

## 3 进程是啥 ##

![20190118164423599.png][]

每个进程都有自己相对独立的**地址空间**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

**进程与程序的区别**

![20190118165026482.png][]

# 二 线程 #

## 1 为毛要在进程中再派生出线程？ ##

### （1）应用的需要 ###

一个多线程的 Web 服务器可以一边接收客户端的请求，一边执行程序，一边响应客户端，提高了效率

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

### （2）开销的考虑 ###

### ![20190118171548607.png][] ###

### （3）性能的需要 ###

一个进程同时有多个任务在执行，提高了软件的运行性能。

## 2 线程和进程的区别 ##

进程是资源分配的基本单位，每个进程都有独立的地址空间，进程切换的开销大

线程是处理器调度的基本单位，线程共享所在进程的地址空间和其他资源，每个线程有独立的内存空间

## 3 线程的基本概念 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

**堆内存**和**方法区**内存共享，**栈内存**独立

java.lang.Thread类充当虚拟的CPU，负责执行代码，处理数据

![20190121094428615.png][]

对应的方法run()称为线程体

## 4 线程的创建 ##

### **4.1 继承Thread类，重写run()** ###

public class Thread implements Runnable {
    
    .......
    
    }

public class FactorialThread extends Thread{//factorial阶乘的
    	private int num;
    	public FactorialThread(int num) {
    		this.num = num;
    	}
    	
            //将想要执行的代码写在run()
    	public void run() {
    		int i = num;
    		int result = 1;
    		
    		System.out.println("new thread started");
    		while(i>0) {
    			result = result * i;
    			i--;
    		}
    		System.out.println("The factorial of" + num + "is " + result);
    		System.out.println("new thread end");
    	}
    }
    
    public class FactorialThreadTest {
    	public static void main(String[] args) {
    		System.out.println("main thread starts");
    		
    		FactorialThread factorialThread = new FactorialThread(10);
    	      //调用start()线程进入就绪状态，然后线程调度机制自动调用run()使线程进入运行状态
    		factorialThread.start();
    		
    		System.out.println("main thread ends");
    	}
    }

**运行结果**

> main thread starts  
> main thread ends //说明main线程已经执行完后，新线程才执行完  
> new thread started  
> The factorial of10is 3628800  
> new thread end

### **4.2 实现Runnable接口（推荐）** ###

public interface Runnable {
      
        public abstract void run();
    }

便于多个线程共享资源

Java不支持多继承，若已经继承某个基类，便需要实现Runnable接口来生成多线程

**单线程例子**

public class FactorialThread implements Runnable{//factorial阶乘的
    	private int num;
    
    	public FactorialThread(int num) {
    		this.num = num;
    	}
    	
            //将想要执行的代码写在run()
    	public void run() {
    		int i = num;
    		int result = 1;
    		
    		while(i>0) {
    			result = result * i;
    			i--;
    		}
    		
    		System.out.println("The factorial of" + num + "is " + result);
    		System.out.println("new thread ends");
    	}
    }
    
    public class FactorialThreadTest {
    	public static void main(String[] args) {
    		System.out.println("main thread starts");
    
    		//FactorialThread实现了Runnable接口
    		FactorialThread factorialThread = new FactorialThread(10);
    		
                    //运行FactorialThread的run()
    		new Thread(factorialThread).start(); 
    		
    		System.out.println("new thread started, main thread ends");
    	}
    }

**执行结果**

> main thread starts  
> new thread started, main thread ends  
> The factorial of10is 3628800  
> new thread ends

**多线程例子**

public class TestThread implements Runnable{
    	private int sleepTime;
    	
    	public TestThread() {
    		sleepTime = (int)(Math.random()*6000);
    	}
    
    	public void run() {
    		try {
    			System.out.println(
    					Thread.currentThread().getName() + " going to sleep for" + sleepTime);
    			Thread.sleep(sleepTime);
    		}
    		catch(InterruptedException exception) {
    			System.err.println(Thread.currentThread().getName()+" finished");
    		};
    	}
    }
    
    public class ThreadSleepTester {
    	public static void main(String[] args) {
    		TestThread thread1 = new TestThread();
    		TestThread thread2 = new TestThread();
    		TestThread thread3 = new TestThread();
    		
    		System.out.println("starting threads");
    		
    		new Thread(thread1,"Thread1").start();
    		new Thread(thread2,"Thread2").start();
    		new Thread(thread3,"Thread3").start();
    		
    		System.out.println("Threads started, main ends");
    	}
    }

**执行结果**

> starting threads  
> Threads started, main ends  
> Thread2 going to sleep for2416  
> Thread1 going to sleep for3239  
> Thread3 going to sleep for1768

### **4.3 两种线程构造方式的比较** ###

（1）Runnable 里只有一个 run() 方法，它定义了需要执行的内容。Thread 类负责线程启动和属性设置等内容，权责分明，实现了 Runnable 与 Thread 类的解耦；

（2）使用继承 Thread 类方式，每次执行一次任务，都需要新建一个独立的线程，执行完任务后线程走到生命周期的尽头被销毁；使用实现 Runnable 接口的方式，就可以把任务直接传入线程池，使用一些固定的线程来完成任务，不需要每次新建销毁线程，大大降低了性能开销；

（3）Java 语言不支持双继承，一旦继承了 Thread 类，那么后续就没有办法再继承其他的类，不利于拓展。

## 5 线程的状态 ##

### 5.1 5种基本状态 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6][]

### 5.2 6种状态 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7][]

## 6 线程间的通信 ##

###  ###

### 6.1 **wait() 和 notify()** ###

wait() 和 notify() 让线程间可以更好地沟通，它们都是 Object 类里的方法

![20190122165411976.png][]

public class Object {
     
        public final native void notify();
        public final native void notifyAll();
     
        public final void wait() throws InterruptedException {
            wait(0L);
        }
        ...
     
    }

利用 wait() 和 notify() 实现售票功能

public class Tickets {
    	int size;         //总票数
    	int number = 0;   //存票序号
    	
    	boolean available = false;    //表示目前是否有票可售
     
    	public Tickets(int size) {
    		this.size = size;
    	}
    	
    	//同步方法，实现存票的功能
    	public synchronized void put() {
    		if(available)//available=true表示还有票可售，就先不生产
    			try {
    				wait();//暂停执行，进入等待池，释放锁
    			} catch (InterruptedException e) {}
    		System.out.println("Producer puts ticket " + (++number));
    		available = true;
    		notify();//唤醒售票线程开始售票
    	}
    	
    	//同步方法，实现售票的功能
    	public synchronized void sell() {
    		if(!available)//available=false表示无票可售
    			try {
    				wait();
    			} catch (InterruptedException e) {}
    		
    		System.out.println("Consumer buys tickets" +number);
    		available = false;
    		notify();//唤醒存票线程开始存票
    		
    		//number>size表示售票结束
    		if(number==size)
    			number=size+1;
    	}
    }

### 6.2 notify() 和 notifyAll() 的区别 ###

notify() 方法不能唤醒某个具体的线程，所以只有一个线程在等待的时候它才有用武之地。而 notifyAll() 唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。

### **6.3 wait() 和 sleep() 方法的区别？** ###

（1）相同点

*  它们都可以让线程阻塞；
 *  它们都可以响应 interrupt 中断：在等待的过程中如果收到中断信号，都可以进行响应，并抛出 InterruptedException 异常；

（2）不同点

*  wait 方法必须在 synchronized 保护的代码中使用，否则会抛异常，而 sleep 方法并没有这个要求；
 *  在同步代码中执行 sleep 方法时，并不会释放 monitor 锁，但执行 wait 方法时会主动释放 monitor 锁；
 *  sleep 方法中会要求必须定义一个时间，时间到期后会主动恢复，而对于没有参数的 wait 方法而言，意味着永久等待，直到被中断或被唤醒才能恢复，它并不会主动恢复；
 *  wait 是 Object 类的方法，而 sleep 是 Thread 类的方法；

**插入一个问题：怎么检测一个线程是否持有 monitor 锁？**

> 调用 java.lang.Thread 中的 holdsLock()

### 6.4 **为什么 wait(), notify() 和 notifyAll() 不在 Thread 类而在 Object 类里？** ###

因为 java 提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得，而 wait，notify 和 notifyAll 都是锁级别的操作。

# 三 死锁 #

死锁就是两个或多个线程（或进程）**被无限期地阻塞，相互等待对方手中资源**的一种状态。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 9][]

## 1 发生死锁的 4 个必要条件 ##

*  互斥使用：一个资源只能给一个线程使用
 *  占有且等待：申请新的资源的同时保持对原有资源的占有
 *  不可抢占：资源申请者不能强行从资源占有者手中夺取资源，资源只能由占有者自愿释放
 *  循环等待：p1 等待 p2 占有的资源，p2 等待 p1 占有的资源

**手写一个会导致死锁的程序**

/**
    
     * 描述：     必定死锁的情况
    
     */
    
    public class MustDeadLock implements Runnable {
    
        public int flag;
        static Object o1 = new Object();
        static Object o2 = new Object();
    
        public void run() {
    
            System.out.println("线程"+Thread.currentThread().getName() + "的flag为" + flag);
            if (flag == 1) {
                // 互斥使用，使用 synchronized 互斥锁，它的锁对象 o1、o2 只能同时被一个线程所获得
                synchronized (o1) {
                    try {
                        Thread.sleep(500);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // 占有且等待，占有 o1，尝试获取 o2
                    synchronized (o2) {
                        System.out.println("线程1获得了两把锁");
                    }
                }
            }
            if (flag == 2) {
                synchronized (o2) {
                    try {
                        Thread.sleep(500);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    synchronized (o1) {
                       System.out.println("线程2获得了两把锁");
                    }
                }
            }
        }
    
        public static void main(String[] argv) {
    
            MustDeadLock r1 = new MustDeadLock();
            MustDeadLock r2 = new MustDeadLock();
    
            r1.flag = 1;
            r2.flag = 2;
    
            Thread t1 = new Thread(r1, "t1");
            Thread t2 = new Thread(r2, "t2");
    
            t1.start();
            t2.start();
    
        }
    
     }

##  ##

[20190118164109166.png]: /images/20220325/f27f9a899aeb44008880d82c8b914e07.png
[Link 1]: http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: /images/20220325/5f17e41e1bd24bb394303c2d75703840.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: /images/20220325/e2438b2d7962401f82b249897d3be054.png
[20190118164423599.png]: /images/20220325/7e05ee01a75344989d92f279c157e350.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: /images/20220325/d523bfa42848438fb34e12cce9a5a9f4.png
[20190118165026482.png]: /images/20220325/b350d45c18584eaa9e2e839697a166a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: /images/20220325/2795b37fac3b47f59f08f7112b2e659a.png
[20190118171548607.png]: /images/20220325/8d85a89c0d3645dbbedce654c839c184.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: /images/20220325/33a369a9a6e142b9a5b40265f3557256.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: /images/20220325/d397a8394e9046949ab8b36e20286e4e.png
[20190121094428615.png]: /images/20220325/c44f00f49bdb4685bdc2f57341fbac3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6]: /images/20220325/b152ff7ae92d492eb2269752da917e51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7]: /images/20220325/abec054b6e364998a0ea145cbc851b34.png
[20190122165411976.png]: /images/20220325/7ee6ca76e7074c7c874684df0359f057.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8]: /images/20220325/e60845ce77524639a7745b9ee81f44e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 9]: /images/20220325/553f489523ce4d2faefe69636df4a8d5.png