线程学习-线程锁机制synchronized、同步方法、线程池（二）

若想解决线程安全问题，需要将线程异步操作变成同步操作

1、锁机制

Java提供了一种内置的锁机制，synchronized关键字就是java中的同步锁

2、synchronized使用方法

synchronized修饰非静态方法：同步方法

synchronized修饰静态方法：静态方法锁

synchronized块：同步块

线程进入同步代码块之前会自动获取锁，并且在推出代码块时会自动释放锁

无论是通过正常途径结束还是通过抛出异常退出都一样释放锁

3、同步方法

当一个方法是用synchronized修饰，该方法称为同步方法。

即多个线程不能“同时”执行该方法，只能先后顺序的同步执行，这样就会导致该方法从多线程异步操作变成同步操作，间接的解决了线程并发操作所带来的的线程安全问题

当方法上使用synchronize那么上锁的对象就是当前方法所属的对象，也就是this

package com.topxin.thread;

public class SynchronizedDemo1 {	
	public static void main(String[] args) {
		final Card c = new Card();
		Thread t1 = new Thread() {
			@Override
			public void run() {
				while(true) {
					int b = c.getMoney();
					Thread.yield();//模拟线程切换
					System.out.println("t1:"+b);
				}
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				while(true) {
					int b = c.getMoney();
					Thread.yield();//模拟线程切换
					System.out.println("t2:"+b);
				}
			}
		};
		t1.start();
		t2.start();
	}
}
class Card{
	private int money = 20;
	/**
	 * 当一个方法使用synchronized修饰，该方法称为同步方法。
	 * 即多个线程不能"同时"执行该方法，只能先后顺序的同步执行
	 * 这样就会导致该方法从多线程异步操作变成同步操作
	 * 间接的解决了线程并发操作所带来的的线程安全问题
	 */
	public synchronized int getMoney() {		//模拟取钱
		if(money == 0) {
			throw new RuntimeException("没有钱了。。。");	//如果没钱主动抛出异常
		}
		Thread.yield();	//模拟线程切换
		return money--;
	}
}

4、静态方法锁

当静态方法上面用synchronized修饰，该方法称为静态方法，那么该方法锁的对象就是类的对象，该方法一定具有同步效果。

实际上上锁的对象为当前方法所属的类的对象，即Class的实例，每个类有且仅有一个Class实例，在该Class内部记录这个类的信息

package com.topxin.thread;

public class SynchronizedDemo2{	
	public static void main(String[] args) {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				Foo.doSome();
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				Foo.doSome();
			}
		};
		t1.start();
		t2.start();
	}
}
class Foo{
	public synchronized static void doSome() {
		Thread t = Thread.currentThread();
		System.out.println(t.getName()+":正在执行该方法。。。");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(t.getName()+":执行该方法结束。。。");
	}
}

5、同步块

使用同步块可以更精确的控制需要同步执行的代码片段，这样可以保证在并发安全的前提下，有效的缩小同步范围，

尽可能的提高并发效率

同步块需要自行指定"同步监视器"即上锁的对象。必须保证多个需要同步执行的线程看到的是同一个对象，通常是this

package com.topxin.thread;

public class SynchronizedDemo3 {	
	public static void main(String[] args) {
		final Shop shop = new Shop();
		Thread t1 = new Thread() {
			@Override
			public void run() {
				shop.buy();
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				shop.buy();
			}
		};
		t1.start();
		t2.start();
	}
}
class Shop{
	public void buy() {
		try {
			Thread t = Thread.currentThread();
			System.out.println(t.getName()+"正在挑选衣服。。。");
			Thread.sleep(2000);
			
			synchronized (this) {
				System.out.println(t.getName()+"正在试衣服。。。");
				Thread.sleep(2000);
			}
			System.out.println(t.getName()+"结账离开");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

6、互斥锁

当synchronized修饰几段不同的代码片段，但是同步监视器相同时，那么这几段代码就存在互斥关系，即多个线程不能同时执行这几段代码

package com.topxin.thread;

public class SynchronizedDemo4 {	
	public static void main(String[] args) {
		final Boo boo = new Boo();
		Thread t1 = new Thread() {
			@Override
			public void run() {
				boo.methodA();
			}
		};
		Thread t2 = new Thread() {
			@Override
			public void run() {
				boo.methodB();
			}
		};
		t1.start();
		t2.start();
	}
}
class Boo{
	public synchronized void methodA() {
		Thread t = Thread.currentThread();
		System.out.println(t.getName()+":执行A方法");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(t.getName()+"A方法执行结束");
	}
	public synchronized void methodB() {
		Thread t = Thread.currentThread();
		System.out.println(t.getName()+":执行B方法");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(t.getName()+"B方法执行结束");
	}
}

7、线程池

当一个程序中若创建大量的线程，并在执行结束后销毁，会给系统带来过度销毁资源，从而可能导致系统崩溃。所以我们应该使用线程池来解决这样的问题

线程池的作用：1）控制线程数量  2）重用线程

并发量大会导致CPU过度切换，导致拖慢系统，耗费系统资源，严重时可能会导致系统崩溃，频繁的创建和销毁线程也会给系统带来负担。

8、线程池的原理

首先创建一些线程，他们的集合称为线程池

当服务接收到一个客户请求，就从线程池中取出一个空闲的线程，去执行任务，如果线程池中没有空闲的线程，则等待其他线程执行完任务后再分配，当服务完毕之后，该线程归还给线程池，而不是关闭销毁

package com.topxin.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 演示线程池
 */
public class ThreadPoolDemo {	
	public static void main(String[] args) {
		//创建一个线程池并指定线程数量为2
		ExecutorService threadPool = Executors.newFixedThreadPool(2);
		//创建5个任务
		for (int i = 0; i < 5; i++) {
			Runnable r = new Runnable() {
				@Override
				public void run() {
					Thread t = Thread.currentThread();
					System.out.println(t.getName()+":正在执行任务");
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(t.getName()+":运行执行完毕....");
				}
			};
			//将任务交给线程池，由线程池分配
			threadPool.execute(r);
		}
		/**
		 * shutdown()当线程池所有的任务执行结束之后。关闭线程
		 * shutdownNow()立即中断正在运行的线程，并停止线程池
		 */
		//threadPool.shutdownNow();
		threadPool.shutdown();
		System.out.println("---------------------");
	}
}

10、常用的线程API

StringBuffer 是线程安全的，同步处理，性能稍慢

StringBuilder是线程不安全，异步处理，性能稍快

对于集合和Map而已，可以使用Collections提供的静态方法将已有的集合和Map转换成线程安全的集合或者Map

package com.topxin.thread;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class SynchronizedAPIDemo {	
	public static void main(String[] args) {
		//ArrayList和LinkedList都是非线程安全的
		List<String> list=new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		System.out.println(list);
		//将给定的list集合转换成线程安全的list集合
		list = Collections.synchronizedList(list);
		System.out.println(list);
		//HashSet是非线程安全的
		Set<String> set=new HashSet<String>(list);
		System.out.println(set);
		//将给定的list集合转换成线程安全的list集合。
		set=Collections.synchronizedSet(set);
		//HashMap是非线程安全的，HashTable是线程安全的
		Map<String,Integer>map=new HashMap<String,Integer>();
		map.put("语文", 99);
		map.put("数学", 88);
		map.put("英语", 60);
		System.out.println(map);
		map=Collections.synchronizedMap(map);
		System.out.println(map);
	}
}