/**
 * synchronized 修饰实例<a href="https://www.f2er.com/tag/fangfa/" target="_blank" class="keywords">方法</a>
 */
public synchronized void increase(){
    i++;
}
@Override
public void run() {
    for(int j=0;j<1000000;j++){
        increase();
    }
}
public static void main(String[] args) throws InterruptedException {
    AccountingSync instance=new AccountingSync();
    Thread t1=new Thread(instance);
    Thread t2=new Thread(instance);
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
}
/**
 * <a href="https://www.f2er.com/tag/shuchu/" target="_blank" class="keywords">输出</a>结果:
 * 2000000
 */

上述代码中，我们开启两个线程操作同一个共享资源即变量i，由于i++;操作并不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于increase方法必须使用synchronized修饰，以便保证线程安全。此时我们应该注意到synchronized修饰的是实例方法increase，在这样的情况下，当前线程的锁便是实例对象instance，注意Java中的线程同步锁可以是任意对象。从代码执行结果来看确实是正确的，倘若我们没有使用synchronized关键字，其最终输出结果就很可能小于2000000，这便是synchronized关键字的作用。这里我们还需要意识到，当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，但是其他线程还是可以访问该实例对象的其他非synchronized方法，当然如果是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1)，另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2)，这样是允许的，因为两个实例对象锁并不同相同，此时如果两个线程操作数据并非共享的，线程安全是有保障的，遗憾的是如果两个线程操作的是共享数据，那么线程安全就有可能无法保证了，如下代码将演示出该现象：

/**
 * 作用于静态<a href="https://www.f2er.com/tag/fangfa/" target="_blank" class="keywords">方法</a>,锁是当前class对象,也就是
 * AccountingSyncClass类对应的class对象
 */
public static synchronized void increase(){
    i++;
}

/**
 * 非静态,访问时锁不一样不会发生互斥
 */
public synchronized void increase4Obj(){
    i++;
}

@Override
public void run() {
    for(int j=0;j<1000000;j++){
        increase();
    }
}
public static void main(String[] args) throws InterruptedException {
    //new新实例
    Thread t1=new Thread(new AccountingSyncClass());
    //new心事了
    Thread t2=new Thread(new AccountingSyncClass());
    //启动线程
    t1.start();t2.start();

    t1.join();t2.join();
    System.out.println(i);
}

代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

//class对象锁

synchronized(AccountingSync.class){

for(int j=0;j<1000000;j++){

i++;

}

}