java synchronized是什么_java synchronized究竟锁住的是什么

刚学java的时候，仅仅知道synchronized一个线程锁。能够锁住代码，可是它真的能像我想的那样，能够锁住代码吗？

在讨论之前先看一下项目中常见关于synchronized的使用方法：

public synchronized void syncCurrentObject() {

System.out.println(Thread.currentThread().getName()+"..start.."+"-----"+System.currentTimeMillis());

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"..end.."+"-----"+System.currentTimeMillis());

}

这样是否能在多个线程訪问时候，保证仅仅有一个线程进入方法。其他线程堵塞吗？

我用线程池创建三个线程容量，分别启动五个线程：

public static void syncCurrentObjectTest() {

ExecutorService exec = Executors.newFixedThreadPool(3);

// final GenerateCode gCode = new GenerateCode();

for (int i = 0; i < 5; i++) {

exec.execute(new Runnable() {

@Override

public void run() {

GenerateCode gCode = new GenerateCode();

gCode.syncCurrentObject();

}

});

}

exec.shutdown();

}

运行效果截图：

依据截图的输入日志说明将synchronized加在方法上并不能让线程安全，而是多个线程并行运行。比方：线程3并没有等线程1运行完毕后再运行。而是线程1休眠的时候。线程3直接获得锁。进行运行。那么在原有的实现上。假设保证线程安全呢？

解决思路：在多个线程调用synchronized修饰的方法时，调用synchronized方法是同一个对象。

详细解决方式是：将GenerateCode 对象创建一次(写成单例更好)。然后调用synchronized修饰方法。

详细改动截图例如以下：

为什么这样改就能够呢？原理是由于对于成员方法。synchronized仅仅能锁住当前对象的线程，其他对象的线程无法锁住。

并且synchronized放在方法和在方法内synchronize(this)是等价的。都仅仅能锁住当前对象。

可是假设想锁住不同对象的多个线程。该怎么做呢？演示样例代码例如以下：

//直接在静态方法上加synchronized 线程安全

public synchronized static void syncStatic() {

//dosomething..

}

//在静态方法上synchronized当前类 线程安全

public static void syncCurrentClass() {

synchronized(GenerateCode.class){

//dosomething..

}

}

//在成员方法上synchronized当前类 线程安全

public void syncCurrentObjectByThisClass() {

synchronized(GenerateCode.class){

//dosomething..

}

}

用synchronized锁住当前类字节码，当前类中总是仅仅有一个线程能够进入运行，其他线程进入堵塞。

总结：synchronized能够锁当前对象，也能够锁类。

synchronized锁住当前对象的写法：

public synchronized void a(){

}

public void ab(){

synchronized (this){

}

}

synchronized锁住当前类的写法：

public synchronized static void a(){

}

public static void a(){

synchronized (类名){

}

}

public void ab(){

synchronized (类名){

}

}

我的理解是：当synchronized作用在对象时候，同一个对象中的线程是相互排斥的，仅仅有一个线程运行完毕后。另外一个线程才干获得对象锁得到运行。

假设不是同一个对象，则不会产生相互排斥

当synchronized作用在类时，对于同一个jvm中不同对象的多个线程调用同一个synchronized修饰的方法都是相互排斥的。由于一个jvm仅仅会产生一个class文件。

拓展：

1、假设想让线程相互排斥，synchronized方法是否存在效率问题？

理论应该是存在效率问题的，由于每一个对象都有一个对象锁，当一个线程拿到锁后，其他线程必须堵塞。(未写代码測试)

2、假设是分布式的系统，使用synchronized无效了。由于synchronized最多仅仅能锁住当前JVM的线程。对于其他server的线程无能为力。

那么怎么处理呢？

查了些资料。网上说能够用zookeeper+其他组件完毕分布式锁或者乐观锁。

由于没有详细实践过。仅仅是看了几篇文章。没有发言权，所以感兴趣的朋友能够自行搜索 java+分布式锁