线程安全——线程经典面试Synchronized/CountDownLatch/volatile

Synchronized(同步)

同步:synchronized
    同步的概念就是共享,我们要牢牢记住"共享"这俩个字,如果不是共享的资源,
就没有必要进行同步。
异步:asynchronized(伪代码不是JDK代码)
    异步的概念就是独立,相互之间不受到任何制约。就好像我们学习http的时候,
在页面发起的Ajax请求,我们还可以继续浏览或操作页面的内容,二者之间没有任何关系。
    同步的目的就是为了线程安全,其实对于线程安全来说,需要满足俩个特性:
    原子性(同步)
    可见性		

线程之间通信( wait 和 notify 必须配合 synchronized 关键字使用 wait方法释放锁,notify方法不释放锁)

线程通信概念:
    线程是操作系统中独立的个体,但这些个体如果不经过特殊的处理就不
能成为一个整体,线程间的通信就成为整体的必用方式之一。当线程存在通信指挥,系
统间的交互性会更强大,在提高CPU利用率的同时还会使开发人员对线程任务在处理的过
程中进行有效的把控与监督。
    使用wait / notify 方法实现线程间的通信。(注意这两个方法都是object的类的方法,
换句话说java为所有的对象都提供了这两个方法)
    wait 和 notify 必须配合 synchronized 关键字使用
    wait方法释放锁,notify方法不释放锁

1.如题,有两个线程A、B,A线程向一个集合(List) 里面依次添加元素“abc”字符串, 一共添加十次,当添加到第五次的时候,希望B线程能够收到A线程的通知,然后B线程执行相关的业务操作,我们应该如何进行设计?

整体思想是:B线程等待被唤醒执行业务。

final Object lock = new Object();//定义对象锁,供两个线程之间通信

等待的代码用while(true)循环,A线程写唤醒B的逻辑

没有及时通知B线程处理任务

package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;

public class ListAdd1 {

	// 1 定义的承装字符串的容器
	private static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd1 list1 = new ListAdd1();
		
		final Object lock = new Object();
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					synchronized (lock) {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程:" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
							if(list.size() == 5) {
								System.err.println("已经发出了唤醒通知!");
								lock.notify();
							}
						}						
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					synchronized (lock) {
						if(list1.size() != 5) {
							try {
								lock.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						}
					}
					//if(list1.size() == 5){
						System.out.println("当前线程收到通知:" + Thread.currentThread().getName() + " list size = 5 线程停止..");
						throw new RuntimeException();
					//}
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}
	
	
}

执行结果分析:

线程安全——线程经典面试Synchronized/CountDownLatch/volatile_第1张图片

A循环结束后才唤醒B,是因为wait方法释放锁,notify方法不释放锁

2方法二设计

不使用synchronized,不使用lock

final CountDownLatch latch = new CountDownLatch(1);//想发出一个通知

A线程:

latch.countDown();//countDown的次数对应new CountDownLatch(1)

B:线程:

latch.await();//
package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class ListAdd2 {

	// 1 定义的承装字符串的容器
	private static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd2 list1 = new ListAdd2();
		
		final CountDownLatch latch = new CountDownLatch(1);
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程:" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
							if(list.size() == 5) {
								System.err.println("已经发出了唤醒通知!");
								latch.countDown();
							}
						}						
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
						if(list1.size() != 5) {
							try {
								latch.await();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
					}
					System.out.println("当前线程收到通知:" + Thread.currentThread().getName() + " list size = 5 线程停止..");
					throw new RuntimeException();
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}
	
}

 实现了:A执行中就唤醒B线程。而不是在A执行后才会执行B.

方法三:volatile关键字

// 1 定义的承装字符串的容器
private volatile static List list = new ArrayList();   //被volatile修饰的变量(共享变量)会在多个线程可见
package com.bfxy.thread.core.safely;

import java.util.ArrayList;
import java.util.List;

public class ListAdd3 {

	// 1 定义的承装字符串的容器
	private volatile static List list = new ArrayList();	
	
	// 2 追加方法
	public void add(){
		list.add("bfxy");
	}
	public int size(){
		return list.size();
	}
	
	public static void main(String[] args) {
		
		final ListAdd3 list1 = new ListAdd3();
		
		// 线程A
		Thread A = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
						for(int i = 0; i <10; i++){
							list1.add();
							System.out.println("当前线程:" + Thread.currentThread().getName() + ", 添加了一个元素..");
							Thread.sleep(500);
						}						
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}, "A");
		
		
		// 线程B
		Thread B = new Thread(new Runnable() {
			@Override
			public void run() {
				while(true){
					if(list1.size() == 5){
						System.out.println("当前线程收到通知:" + Thread.currentThread().getName() + " list size = 5 线程停止..");
						throw new RuntimeException();
					}
				}
			}
		}, "B");	
		
		B.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		A.start();
		
	}
	
}

你可能感兴趣的:(Thread,volatile)