非线程安全的概念

多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的问题。

1、synchronized关键字

1.1 锁定对象Object

public class MyObject
{
    synchronized public void methodA()
    {
      ...
    }
}

• 关键字synchronized取得的锁是对象锁，而不是针对一个代码块或者函数，其他的线程必须等待当前线程完成释放锁后才可以获得该对象锁。排队执行！

1、线程A调用对象中加入synchronized的关键字的方法X，线程A持有对象锁，但线程B可以随意调用对象中的非synchronized方法。
2、线程A调用对象中加入synchronized的关键字的方法X，线程A持有对象锁，若线程B想调用对象中其他有synchronized关键字的非X方法，也必须等待线程A完成调用并释放锁。

• 关键词synchronized拥有锁重入的功能，也就是在使用synchronized时，当线程得到该对象的锁后，再次请求该对象的锁是可以获得的，也就是可以在一个synchronized方法/块中可以直接调用本类的其他synchronized方法/块。

存在父子类继承关系时，子类可以通过“可重入锁”访问父类的同步方法。
父类、子类均需要加synchronized关键字。

public class Main
{
    public int i = 10;
    synchronized public void operateIMainMethod()
    {
        try
        {
            i--;
            Thread.sleep(100);
        }
        catch(InterruptedException e)
        {
        }
    }
}

public class Sub extends Main
{
    synchronized public void operateISubMethod()
    {
        try
        {
            while(i>0)
            {
                i--;
                Thread.sleep(100);
                this.operateIMainMethod();
            }
        }
        catch(InterruptedException e)
        {
        }
    }     
}

//此代码实现功能：父类公有变量i，子类和父类轮番减1直到值为0
public class MyThread extends Thread
{
    @Override
     public void run()
     {
          Sub sub = new Sub();
          sub.operateISubMethod 
     }
}

• 若线程中synchronized关键词修饰的方法中出现异常，则锁会被自动释放。

1.2 同步代码块

1.2.1 synchronized(this)

使用synchronized关键词修饰方法实现同步的弊端：
排队执行，运行耗时。
使用同步代码块分离方法中的代码，减少运行时间。

synchronized(this)
{
   ...
}

• 当两个并发线程同时访问同一个对象的synchronized(this)代码块时，执行该代码块的线程持有当前调用对象的锁，在同步代码块中是同步执行，在非synchronized(this)代码块中就是异步执行。
• 当一个线程访问object的一个同步代码块时，其他线程对同一个object中其他synchronized(this)同步代码块的访问会被阻塞，当前对象被锁定。

1.2.2 synchronized(非this对象)

“任意对象”作为对象监视器，如实例变量及方法的参数。

public class Service
{
    private String usernameParam;
    private String passwordParam;
    private String anyString = new String();
    public void setUsernamePwd(String name, String password)
    {
        //private String anyString = new String();
        //此行代码不可放在此处，不然无法保证同步性
        try
        {
            synchronized(anyString)
            {
               usernameParam = name;
               passwordParam = password;
               Thread.sleep(100);
            }
        }
        catch(InterruptedException e)
        {
        }
    }
}

public class ThreadA extends Thread
{
    private Service service;
    public ThreadA()
    {
        super();
        this.service = service;
    }

    @Override
    public void run()
    {
        service. setUsernamePwd("a","aa");
    }
}

优点：如果一个类中有很多个synchronized方法，虽然能实现同步，但是会收到阻塞，所以影响运行效率；使用同步代码块锁非this对象，不与其他synchronized同步方法争抢this锁，提高运行效率。
缺点：因为“对象监视器”不同，可能出现“脏读”，使用时需注意。

• 当多个线程同时执行synchronized(非this对象x){} 同步代码块时呈同步效果。
• 当其他线程执行x对象中synchronized同步方法时呈同步效果。
• 当其他线程执行x对象方法里面的synchronized(this)代码块时也呈现同步效果。

1.3 静态同步方法与synchronized(class)代码块

• 关键字synchronized可以应用在static静态方法上，相当于对当前的*.java文件对应的Class类持锁，与synchronized(class)作用相同。

1.3.1 对象锁和Class锁不同

public class Service
{
    synchronized public static void printA()
    {
    }

    synchronized public static void printB()
    {
    }

    //printC方法与printA,printB方法无法保持同步
    //一个是Class锁，一个是对象锁
    synchronized public void printC()
    {
    }
}

1.3.2 Class锁对该Class所有的对象都有效

public class Run
{
    public static void main(String[] args)
    {
        //可实现同步，Service类的Class锁！！
        Service service1 = new Service();
        Service service2 = new Service();
        Thread threadA = new Thread(service1);
        threadA.start();
        Thread threadB = new Thread(service2);
        threadB.start();
        
    }
}

1.4 死锁

不同的线程都在等待不可能被释放的资源，就会导致任务无法继续完成。哪怕运行结果正常也有可能出现死锁，有互相等待对方释放资源的情况就有可能出现死锁。

1.5 锁对象的改变

将任意数据类型作为同步锁的时候，需要判断是否有多个线程同时持有相同的锁对象，若是则同步，若不是则异步。以String类型对象“123”作为同步锁，若线程去获取锁的时候获取都是该值则为同步，哪怕后续该值改变；若有其他线程在值改变后再获取锁，则该线程不同步。

2、volatile关键字

作用：修饰变量
强制从公共堆栈中取得变量的值，而不是从线程私有对象数据栈中取得变量的值。

• 多线程访问volatile不会出现阻塞，synchronized会出现阻塞。
• volatile可以保证可见性，但是不能保证原子性，即其不能保证线程安全。
• 如对变量++的操作，可以使用原子类如AtomicInteger实现原子操作。不安全性：方法与方法之间的调用不是原子的。