一、线程同步
并发：同一个对象被多个线程同时操作
（1）为什么会需要线程同步？
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
（2）线程同步的条件
队列+锁
（3）锁存在的问题
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制，synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在问题：
（a）一个线程持有锁会导致其他所有需要此锁的线程挂起；
（b）在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟，引起性能问题；
(c) 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。
二、实例展示
（1）在没有任何保护措施，两个线程同时执行。
package com.collection.sys;
//不安全的取钱
//两个人去银行取钱，账号
public class UnSafeBack {
public static void main(String[] args) {
//账户
Account account = new Account(100,"结婚基金");
Drawing you = new Drawing(account,50,"您");
Drawing girlFriend = new Drawing(account,100,"grilFriend");
you.start();
girlFriend.start();
}
}
//账号
class Account{
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account; //账号
//取了多谢前
int drawingMoney;
//现在手里还有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney,String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
@Override
public void run() {
//判断有没有钱
if (account.money -drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额-你取的前
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name+"余额为："+account.money);
System.out.println(this.getName()+"手里的钱："+nowMoney);
// System.out.println("卡内余额==》"+account.money+"你手里的钱"+nowMoney);
// super.run();
}
}
所以线程是不安全的。
（2）ArrayList也是不安全的
package com.collection.sys;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
三、解决方案
（1）synchronized方法和synchronized块
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制即使synchronized关键字，它包括两种用法：synchronized方法和synchronized块
public synchronized void method(int args){}synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
缺点：若将一个大的方法申明为synchronized将会影响效率
（a）同步块：synchronized(obj)块
obj称之为 同步监视器
obj可以是任何对象，但是推荐使用共享资源作为同步监视器。
同步方法中无序执行同步监视器，因为同步方法的同步监视器就是this，就是对象本身。
同步监视器的执行过程：
（a）第一个线程访问，锁定同步监视器，执行其中代码。
（b）第二个线程访问，发现同步监视器被锁定，无法访问。
（c）第一个线程访问完毕，解锁同步监视器。
（d）第二个线程访问，发现同步监视器没有锁，然后锁定并访问。
可以看出加上了synchronized关键字，就可以正确执行了。
（2）CopyOnWriteArrayList 这个集合是线程安全的
package com.collection.sys;
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
四、线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
1、提高响应速度（减少了创建新线程的时间）
2、降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3、便于线程管理（..)
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间会终止。
JDK5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService:真正的线程池接口，常见子类ThreadPoolExecutor
(1) void execute(runnable command) :执行任务/命令，没有返回值，一般来执行Runnable
（2）<T> Future<T> submit(Callable<T> task):执行任务，有返回值，一般又来执行callable
(3)void shutdown() 关闭连接池
Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
package com.collection.sys;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
public static void main(String[] args) {
//1、创建服务，创建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
//2、关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}