在Java的集合类中，有些是同步不安全的，如HashMap，有些是同步安全的，如HashTable，Vector。
查看源码会发现，这些所谓同步安全的集合，其实现方式 就是 通过在某些方法上，如add，增加synchronized修饰。然后同步就实现了。
同步是什么，同步就是排队，比如公共电话亭打电话，一个电话，现在来了3个人，同步就是说第一个人打完了，第二个人再上，之后第三个人再上。
需要同步的原因是因为有并发，有多个线程，单线程永远没有同步的问题，那本身就是同步的。
多线程也未必就有同步的需要，当众多线程 对于 观察对象，不进行干扰的话，并发也不需要同步，比如看直播，1个人看直播，和10万人看直播，你们只是看的话，是没有并发问题的，不需要同步，只需要把直播画面，拷贝10万份给每个人就可以了。
但下面这种情况就有问题了，10个人在看一个主播直播，其中3个人希望主播换一首歌，换成自己喜欢的，如果这三个请求同时提出，那么主播该怎么办。
如果三首同时放，那不可能，也没法听。
如果随便忽略掉请求，也不算完美的解决办法。
最后的办法只能是 把并行的需求，串行化，一个一个来。
所以同步说白一点，就是排队，一个一个来。
那一个一个来有什么问题呢？ 这不又成单线程了吗
所以这其中的问题是
1，单线程，正确，但一个一个来，处理的太慢。
2，多线程，并发，同时做，肯定速度快，但某些点上，有可能出现错误。
同步就要求，即快，又正确。这就是难点，难在，需要分析出，
在这件事情中，哪些区域是可以并发，也不会出问题的，哪些区域是不能并发，还是要排队的。
所以同步就是 多线程+单线程的组合。
用关键字synchronized，首先要分析出，要对谁进行同步，先看个错误例子，这里面用了synchronized，还是没有达到同步的效果。
class Task implements Runnable{
synchronized void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
某一次输出为
4969
这个程序会创建100个线程，每个线程执行的任务是 对 变量i增加50次， 所以我期望的结果，i最后变成5000了，但事与愿违
这个程序基本每次输出都不一样，但都小于5000.
原因就处在add()方法上， 但我已经给这个方法 加上synchronized关键字了，为什么还是同步不了呢？
这个问题困扰了我很久，直到---
因为我没搞明白一个问题，synchronized是给谁加锁的。
锁在哪儿， Java中，每个对象都是锁，包括实例出来的对象，类本身。
现在回头看这个程序， 我把synchronized加再一个 普通方法上， 这时 锁就是 实例化的Task对象， 它能实现的效果是， 多个线程，在操作这个实例的 add方法时，保证它们是排队进行的。
可我的程序中
Thread t = new Thread(new Task()); 这段代码， 在创建每个线程时，都新创建 了一个 新的Task实例， 等于是100个线程，创建了100把锁，足球场100个人，发了100个球，各玩各的，根本不同竞争。 那么怎么修改呢
简单，只创建一个 Task实例，给100个线程去玩，到时候，自然会竞争add方法的， 代码修改如下
class Task implements Runnable{
synchronized void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
//只创建一个Task ，然后传给100个线程。
Task task = new Task();
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(task);
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
输出
5000
输出5000， 符合预期。 这是synchronized的一种情况，对普通方法加锁，锁是该类实例后的 对象。
synchronized还有两种用法， 修饰静态方法， 和 修饰代码块。
下面的代码是 同步静态方法 的 例子，将原来的add方法改成static的了
class Task implements Runnable{
synchronized static void add(){
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
//只创建一个Task ，然后传给100个线程。
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
输出
5000 符合预期。
在这个例子中， 100个线程 创建了100个Task实例， 但并没有出现 并发的错误， 原因是 add是静态方法， 和具体的实例无关， 即使new100个实例，也是用的一个方法， synchronized修饰静态方法， 对应的锁是这个静态方法的类，所以 同步没有问题。
第三种情况， synchronized代码块
class Task implements Runnable{
void add(){
synchronized (Task.class) {
int tmp = TestMain.i;
tmp = tmp + 1;
TestMain.i = tmp;
}
}
public void run() {
//每个线程会增加50次
for(int i=0;i<50;i++){
add();
}
}
}
public class TestMain {
static int i=0;
static Object o = new Object();
public static void main(String[] args) throws InterruptedException {
// 创建100个线程
for(int i=0;i<100;i++){
Thread t = new Thread(new Task());
t.start();
}
Thread.sleep(1000);
System.out.println(i);
}
}
这次add还是普通方法，而add的函数体 都包含在 synchronized中，
这样写的时候， synchronized后面有个括号， 其中需要一个对象，也就是锁， 这样的好处是 这个锁可以根据需要， 传不同的对象，前面两种方式 一个是 所在实例的作为锁，一个是所在类作为锁，有些不灵活， 第三种方法，你可以将任何对象传进来，这其实是为了 缩小锁定的范围。
毕竟锁定和多线程是矛盾的。一定要选择合适的 同步范围 。
正确性是第一优先的， 如果程序无法保证正确，那就无法使用，
在保证正确性的前提下， 缩小锁定的范围， 提高程序的整体效率，是追求的目标。
