多线程入门四

叁歲伎倆 2023-10-10 11:01 11阅读 0赞

一、线程三大特性：原子性、可见性和有序性

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

示例：银行转账功能  
从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。

可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

有序性：程序执行的顺序按照代码的先后顺序执行。

二、Java 内存模型：

说明：Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。

理解说明：JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

图解说明：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70][]

三、Volatile

简介：变量在多个线程之间可见。

示例：

package com.zzg.lock;
    
    public class VolatileDemo {
    	public  boolean running = true;
    	
    	public boolean isRunning() {
    		return running;
    	}
    
    	public void setRunning(boolean running) {
    		this.running = running;
    	}
    
    	public class Another extends Thread{
    
    		@Override
    		public void run() {
    			System.out.println("AnotherThread is running");
    
                while (running) { 
                	
                }
    
                System.out.println("Another is stoped");
    		}
    		
    	}        
    	public static void main(String[] args) throws InterruptedException {
    		VolatileDemo demo = new VolatileDemo();
    		demo.new Another().start();
    		Thread.sleep(1000);
    		demo.setRunning(false); // 1秒中后停止,Another 线程执行。
    		
    	}
    	
    	
    	}

运行结果:

![20200426000845374.PNG][]

上面这段代码一般情况下都会死锁，就是因为在 main 方法（主线程）中对 running 做的修改，并不能立马对 Another 可见。

针对上述问题，使用volatile 修饰running 属性，修改后的代码:

package com.zzg.lock;
    
    public class VolatileDemo {
    	public volatile  boolean running = true;
    	
    	public boolean isRunning() {
    		return running;
    	}
    
    	public void setRunning(boolean running) {
    		this.running = running;
    	}
    
    	public class Another extends Thread{
    
    		@Override
    		public void run() {
    			System.out.println("AnotherThread is running");
    
                while (running) { 
                	
                }
    
                System.out.println("Another is stoped");
    		}
    		
    	}        
    	public static void main(String[] args) throws InterruptedException {
    		VolatileDemo demo = new VolatileDemo();
    		demo.new Another().start();
    		Thread.sleep(1000);
    		demo.setRunning(false); // 1秒中后停止,Another 线程执行。
    		
    	}
    	
    	
    	}

![20200426001105407.PNG][]

将 running 加上修饰符 volatile，那么便可以获取实际希望的结果，因为此时主线程中设置 running 为 false 之后，Another可以立马发现 running 的值发生了改变：

总结：对于 volatile 修饰的变量，JVM 可以保证：

1、每次对该变量的写操作，都将立即同步到主存；  
2、每次对该变量的读操作，都将从主存读取，而不是线程栈

四、Atomic\* 类

示例：使用AtomicInteger 类

package com.zzg.atomic;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class AtomicDemo {
    	private AtomicInteger atomicInteger = new AtomicInteger(0);
    
    	public class AtomicThread extends Thread {
    
    		@Override
    		public void run() {
    			for (int i = 0; i < 100; i++) {
    				// 等同于i++
    				atomicInteger.incrementAndGet();
    			}
    			System.out.println(atomicInteger.get());
    		}
    
    	}
    
    	public static void main(String[] args) {
    		AtomicDemo demo = new AtomicDemo();
    		// 初始化10个线程
    		AtomicThread[] volatileNoAtomic = new AtomicThread[10];
    		for (int i = 0; i < 10; i++) {
    			// 创建
    			volatileNoAtomic[i] = demo.new AtomicThread();
    		}
    		for (int i = 0; i < volatileNoAtomic.length; i++) {
    			volatileNoAtomic[i].start();
    		}
    	}
    
    }

效果展示:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1][]

五、ThreadLocal

什么是ThreadLocal:

ThreadLocal提供线程的局部变量，当访问某个线程拥有的局部变量。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

ThreadLocal 接口方法：

1、void set(Object value)设置当前线程的线程局部变量的值。

2、public Object get()该方法返回当前线程所对应的线程局部变量。

3、public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

4、protected Object initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

示例：创建三个线程，每个线程生成自己独立序列号。

package com.zzg.atomic;
    
    public class ThreadLocalResource {
    	public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
    		protected Integer initialValue() {
    			return 0;
    		};
    	};
    	
    	public Integer getNum() {
    		int count = threadLocal.get() + 1;
    		threadLocal.set(count);
    		return count;
    	}
    }

package com.zzg.atomic;
    
    public class ThreadLocalThread extends Thread {
    	private ThreadLocalResource resource;
    
    	public ThreadLocalThread(ThreadLocalResource resource) {
    		super();
    		this.resource = resource;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 3; i++) {
    			System.out.println(Thread.currentThread().getName() + "---" + "i---" + i + "--num:" + resource.getNum());
    		}
    	}
    
    }

package com.zzg.atomic;
    
    public class ThreadLocalDemo {
    	
    	public static void main(String[] args) {
    		ThreadLocalResource res = new ThreadLocalResource();
    		ThreadLocalThread threadLoca1 = new ThreadLocalThread(res);
    		ThreadLocalThread threadLoca2 = new ThreadLocalThread(res);
    		ThreadLocalThread threadLoca3 = new ThreadLocalThread(res);
    		threadLoca1.start();
    		threadLoca2.start();
    		threadLoca3.start();
    	}
    
    }

效果展示:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 2][]

ThreadLoca 实现原理 = ThreadLoca通过map集合,Map.put(“当前线程”,值)

六、线程池

什么是线程池:

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中并等待下一次分配任务。

线程池作用:

基于以下几个原因在多线程应用程序中使用线程是必须的：  
1. 线程池改进了一个应用程序的响应时间。由于线程池中的线程已经准备好且等待被分配任务，应用程序可以直接拿来使用而不用新建一个线程。  
2. 线程池节省了CLR 为每个短生存周期任务创建一个完整的线程的开销并可以在任务完成后回收资源。  
3. 线程池根据当前在系统中运行的进程来优化线程时间片。  
4. 线程池允许我们开启多个任务而不用为每个线程设置属性。  
5. 线程池允许我们为正在执行的任务的程序参数传递一个包含状态信息的对象引用。  
6. 线程池可以用来解决处理一个特定请求最大线程数量限制问题。

线程池四种实现方式:

Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：  
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。  
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。  
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。  
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1、newCachedThreadPool线程池：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

示例代码：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    		for (int i = 0; i < 10; i++) {
    			final int index = i;
    			// try {
    			// Thread.sleep(index * 1000);
    			// } catch (InterruptedException e) {
    			// e.printStackTrace();
    			// }
    			cachedThreadPool.execute(new Runnable() {
    				public void run() {
    					System.out.println(Thread.currentThread().getName() + "---" + index);
    				}
    			});
    		}

总结:线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

2、newFixedThreadPool线程池:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

示例代码：

// 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
    		final ExecutorService newCachedThreadPool = Executors.newFixedThreadPool(3);
    
    		for (int i = 0; i < 10; i++) {
    			final int index = i;
    			newCachedThreadPool.execute(new Runnable() {
    				public void run() {
    					try {
    						Thread.sleep(1000);
    					} catch (Exception e) {
    						// TODO: handle exception
    					}
    					System.out.println("i:" + index);
    				}
    			});
    		}

总结:因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

3、newScheduledThreadPool线程池:创建一个定长线程池，支持定时及周期性任务执行。延迟执行

示例代码：

// 创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
    		ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
    		newScheduledThreadPool.schedule(new Runnable() {
    			public void run() {
    				System.out.println("delay 3 seconds");
    			}
    		}, 3, TimeUnit.SECONDS); // 表示延迟3秒执行

4、newSingleThreadExecutor线程池:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

示例代码：

ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
    		for (int i = 0; i < 10; i++) {
    			final int index = i;
    			newSingleThreadExecutor.execute(new Runnable() {
    
    				@Override
    				public void run() {
    					System.out.println("index:" + index);
    					try {
    						Thread.sleep(200);
    					} catch (Exception e) {
    						// TODO: handle exception
    					}
    				}
    			});
    		}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200425232446747.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[20200426000845374.PNG]: https://img-blog.csdnimg.cn/20200426000845374.PNG
[20200426001105407.PNG]: https://img-blog.csdnimg.cn/20200426001105407.PNG
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200426002532740.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200426003743852.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70