Thread

阳光穿透心脏的1/2处 2022-10-16 10:28 136阅读 0赞

### 目录 ###

*  Thread 的 interrupt 函数
 *  Thread 的 sleep 函数
 *   *  sleep 的中断异常
     *  sleep 时不释放资源
 *  Object 的 wait 和 notify 函数
 *   *  wait 会释放资源
 *  线程池
 *  ThreadLocal

# Thread 的 interrupt 函数 #

public void Thread.interrupt()				// 中断线程
    public boolean Thread.isInterrupted()		// 判断是否被中断
    public static boolean Thread.interrupted()	// 判断是否被中断，并清除当前中断状态

// 中断响应方法
    Thread t1 = new Thread(() -> { 
    	while(true) { 
    		if(Thread.currentThread().isInterrupted()) { 
    			break;
    		}
    	}
    });

--------------------

# Thread 的 sleep 函数 #

## sleep 的中断异常 ##

有两个线程A、B，当A执行sleep()时，若B调用了A的interrupt()，实质上是设置中断状态，此时A在睡眠，会触发InterruptedException异常，此时需要捕获异常代码段重新设置中断  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70]

Thread t1 = new Thread(() -> { 
    	while(true) { 
    		if(Thread.currentThread().isInterrupted()) { 
    			break;
    		}
    		// 其他操作
    		try { 
    			Thread.sleep(1000);
    		}catch(InterruptedException e) { 
    			Thread.currentThread().interrupt();
    		}
    		// 其他操作
    	}
    });

## sleep 时不释放资源 ##

线程调用 sleep ，并不会使该线程释放对象锁，而会在睡眠是一直持有，直到睡醒，并执行其余同步块内容，才释放对象锁  
测试代码：

public class Test { 
    	public static Object u = new Object();
    	public static class MyRunnable implements Runnable{ 
    		@Override
    		public void run() { 
    			synchronized (u) { 
    				System.out.println(Thread.currentThread().getName() + " run");
    				try { 
    					Thread.sleep(1000);
    				}catch(InterruptedException e) { 
    					Thread.currentThread().interrupt();
    				}
    				System.out.println(Thread.currentThread().getName() + " finish");
    			}
    		}
    	}
    	public static void main(String args[]) throws InterruptedException { 
    		MyRunnable r = new MyRunnable();
    		Thread t1 = new Thread(r, "t1");
    		Thread t2 = new Thread(r, "t2");
    		t1.start();
    		t2.start();
    	}
    }

测试结果：

![在这里插入图片描述][20210529222452944.png]

--------------------

# Object 的 wait 和 notify 函数 #

wait 和 notify 要与 关键字 **synchronized** 配合使用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70 1]

## wait 会释放资源 ##

执行 wait 的线程会释放对象锁，让其他线程持有，使其他线程能唤醒该线程  
测试代码：

public class Test { 
    	public static Object u = new Object();
    	public static class MyRunnable implements Runnable{ 
    		@Override
    		public void run() { 
    			synchronized (u) { 
    				System.out.println(Thread.currentThread().getName() + " run");
    				try { 
    					u.wait();
    				}catch(InterruptedException e) { 
    					Thread.currentThread().interrupt();
    				}
    				System.out.println(Thread.currentThread().getName() + " finish");
    			}
    		}
    	}
    	public static void main(String args[]) throws InterruptedException { 
    		MyRunnable r = new MyRunnable();
    		Thread t1 = new Thread(r, "t1");
    		Thread t2 = new Thread(r, "t2");
    		t1.start();
    		t2.start();
    		Thread.sleep(1000);
    		synchronized (u) { 
    			u.notifyAll();
    		}
    	}
    }

测试结果：  
![在这里插入图片描述][20210529224538678.png]

--------------------

# 线程池 #

常用创建线程池方法

public static ExecutorService newFixedThreadPool(int nThreads);
    public static ExecutorService newSingleThreadExecutor();
    public static ExecutorService newCachedThreadPool();

它们本质上是通过构造 ThreadPoolExecutor 对象，因 ThreadPoolExecutor 是 ExecutorService 的子孙类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70 2]  
newFixedThreadPool() 方法 和 newSingleThreadExecutor() 方法用的是 LinkedBlockingQueue< Runnable >() ，而且没有拒绝策略，意味着当最大线程数满的时候，若有新的任务提交，则会放到等待队列，若提交数度 > 处理数度，等待队列不断增长，最后内存占满

# ThreadLocal #

多线程访问共享变量可能会线程不安全，若每个线程拥有自己的局部变量，那就不会出现并发问题  
**Demo（SimpleDateFormat.parse()线程不安全 )**

static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<>();
    public static class ParseDate implements Runnable{ 
    	int i = 0;
    	public ParseDate(int i) { this.i = i;}
    	public void run() { 
    		try { 
    			if(t1.get() == null) { 
    				t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    			}
    			Date t = t1.get().parse("2015-03-29 19:29:" + i % 60);
    			System.out.println(i + ":" + t);
    		} catch(ParseException e) { 
    			e.printStackTrace();
    		} finally { 
    			t1.remove();
    		}
    	}
    }

每个 Thread 都有自己的局部变量，它们存放在 threadLocals 中

public class Thread implements Runnable{ 
    	...
    	ThreadLocal.ThreadLocalMap threadLocals = null;
    	...
    }

通过使用 ThreadLocal 的 set() 将要存入的值放入threadLocals 中，当要用的时候使用 get() ，从中获取对应的数据，从而使线程安全

public void set(T value) { 
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) { 
            map.set(this, value);
        } else { 
            createMap(t, value);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70]: /images/20221014/b70a92bffe3241438dcf7355df0a6490.png
[20210529222452944.png]: /images/20221014/4bda3557ad13485d92dfcbad02cc0776.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70 1]: /images/20221014/a4629c38930d46c2b11a20bd73ce8ed5.png
[20210529224538678.png]: /images/20221014/547bbdcaa477427ab036eba765824f6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNjc3ODc2_size_16_color_FFFFFF_t_70 2]: /images/20221014/a0301d536fa7426a9685877277a6b1d4.png