由于多线程并发存在数据不安全问题，为了保证数据的安全性需要一些特殊的手段来维持。数据不安全主要是针对修改来说的，如果一个数据只能读不能修改几乎不会产生什么安全问题。只有修改数据的时候容易产生一些差错导致多线程并发造成数据不安全。
从操作系统的角度来看多线程访问临界资源时并且对临界资源做一定的修改就会产生错误，操作系统为了保证临界资源的安全性，保证每次访问临界资源的线程有且只有一个。多线程访问时会进入等待队列依次排队等待。
Java多线程并发出现数据不安全问题的原因也大致相同，因为某些操作不是原子性的(可以拆开)，例如 i++ 这种操作在CPU看来是比较麻烦的，首先要从内存中将数据i的值读入到当前线程的工作缓存工作区中，然后再将这个值+1。最后才是将值回写到内存中。至少是3步才能完成这样一个操作，因为并发是无法预料这个线程能否在被迫剥夺CPU时间之前完成这个操作有可能在回写值到内存中时此时还没回写完就已经被其他线程剥夺了CPU，那么回写失败之后的线程再去读这个值读到的还是原来的值并没有+1。
为了保证这种上述操作能够完成，必须将三步操作看做一个整体执行时不能中断。只有完成回写之后其他线程才能去继续修改或者读取，这样就能保证正确性。
Java中为了保证多线程并发的数据安全性提供了Synchronized关键字来保证。保证非原子操作执行时不能中断，同时多个线程修改同一个临界资源时必须采用串行执行，并且必须保证前一个线程执行完后一个线程才有机会去访问。就像卫生间一样，一旦从里面上了锁只有里面的人用完了打开了门外面的人才有机会进去。否则就有可能出现两个人同时出现在卫生间中… 所以可以将synchronized看做卫生间的门锁。
class TestA implements Runnable{
public int sum = 0;
public synchronized void cnt(){
sum++;
}
@Override
public void run() {
for(int i = 0;i < 100000;i++){
cnt();
}
}
}
public class FunSyn1{
public static void main(String[] args) throws InterruptedException {
TestA test = new TestA();
Thread t1 = new Thread(test,"A"); //静态代理1
Thread t2 = new Thread(test,"B"); //静态代理2
t1.start(); t2.start();
Thread.sleep(5000); //主线程休眠5秒，让t1 和 t2先跑完
System.out.println(test.sum); //200000
}
}
class TestB implements Runnable{
public static int sum = 0; //静态变量不属于某个具体的对象，是共有的。
public synchronized void cnt(){
sum++;
}
@Override
public void run() {
for(int i = 0;i < 100000;i++){
cnt();
}
}
}
public class FunSyn2{
public static void main(String[] args) throws InterruptedException {
TestB test1 = new TestB();
TestB test2 = new TestB();
Thread t1 = new Thread(test1,"A");
Thread t2 = new Thread(test2,"B");
t1.start(); t2.start();
Thread.sleep(5000); //主线程休眠5秒，让t1 和 t2先跑完
System.out.println(TestB.sum); //小于200000
}
}
小结：出现这种原因是因为加锁的对象不同，对象锁对于这种情况只能锁住从当前对象去访问的线程数目只有一个，但是并不能锁住所有的对象。也就是通向静态sum的路有多条，虽然能保证每条路上只有一辆车，但是我有多条路自然有多辆车可以通过不同的路到达sum。所以对于上面的情况2应该加锁的是sum变量或者是将通向sum的路抽象出来一条路并且这条路每次只有一个车能过，而不是对象上锁这样就能保证访问sum的每次只有一个线程
class TestC implements Runnable{
static int sum = 0;
public static synchronized void cnt(){
sum++;
}
@Override
public void run() {
for(int i = 0;i < 100000;i++){
cnt();
}
}
}
public class StaticSyn {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new TestC(),"A");
Thread t2 = new Thread(new TestC(),"B");
t1.start(); t2.start();
Thread.sleep(5000);
System.out.println(TestC.sum); //200000
}
}
synchronized代码块锁实例化对象，类似于synchronized修饰非静态方法
class TestD implements Runnable{
static int sum = 0;
@Override
public void run() {
synchronized (this){ //对象锁
for(int i = 0;i < 100000;i++){
sum++;
}
}
}
}
public class SynBlockThis {
public static void main(String[] args) throws InterruptedException {
TestD test = new TestD();
Thread t1 = new Thread(test,"A");
Thread t2 = new Thread(test,"B");
t1.start(); t2.start();
Thread.sleep(5000);
System.out.println(test.sum); //200000
}
}
synchronized代码块锁class类，类似于synchronized修饰静态方法
class TestE implements Runnable{
static int sum = 0;
@Override
public void run() {
synchronized (SynBlockClass.class){ //类锁
for(int i = 0;i < 100000;i++){
sum++;
}
}
}
}
public class SynBlockClass{
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new TestE(),"A");
Thread t2 = new Thread(new TestD(),"B");
t1.start(); t2.start();
Thread.sleep(5000);
System.out.println(TestE.sum); //200000
}
}
synchronized的用法大概就这几种情况但是变化很多，主要去判断应该锁对象还是锁类，怎么锁才是关键。但是synchronized并不是万能的，会有死锁的情况发生。
一个线程持有锁会导致其他需要此锁的线程挂起
多线程竞争下，加锁开锁会导致比较多的上下文切换 和 调度延时，引起性能问题。
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。
数据安全有了一定的保证，但是可能引起死锁。