Synchronized的基本使用以及对象锁和类锁的区别

Synchronized关键字特点

• 能够对线程中的某个方法块锁定，从而保证线程执行正确
• 只能够实现非公平锁，而且不能判断是否获取了锁
• 颗粒度比较大，使用不好会造成性能差
• 是JVM级别实现的锁和ReentantLock实现是完全不同的

对象锁和类锁的区别

• 对象锁是只对当前对象加锁，如果是同一个对象那么才会涉及是否做同步
• 类锁故名思议就是对这个class加锁，即使是同类不同的对象也必须同步

先做一个Person的对象做为锁。代码如下：

/**
 * @ClassName: Person
 * @Description: 类描述
 * @Author: bulingfeng
 * @CreateDate: 2019/3/4/004 11:13
 */
public class Person {
    String name;
    String age;
    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public synchronized void test1(Person person){
        System.out.println("name:"+person.getName());
    }
}

通过实现runnable来创建线程对象

import com.xzst.es.entity.Person;

import static java.lang.Thread.sleep;

/**
 * @ClassName: ThreadTest
 * @Description: 类描述
 * @Author: bulingfeng
 * @CreateDate: 2019/3/6/006 23:16
 */
public class ThreadTest implements Runnable{
    Person o1;

    public ThreadTest(Person o1) {
        this.o1 = o1;
    }

    @Override
    public void run() {
                test();
    }
    public void test(){
        synchronized (Person.class){ //请注意这里 如果这里换成o1 则是对具体的某个对象加锁
            for (int i=0;i<10;i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadName；"+Thread.currentThread().getName()+"hello:"+o1.getName());
            }
        }
    }
}

测试类

import com.xzst.es.entity.Person;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName: ReentrantLockTest
 * @Description: 类描述
 * @Author: bulingfeng
 * @CreateDate: 2019/3/6/006 22:47
 */
public class ReentrantLockTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setName("p1");
        Person p2=new Person();
        p2.setName("p2");
        ThreadTest threadTest1=new ThreadTest(p1);
        ThreadTest threadTest2=new ThreadTest(p2);
        Thread t1=new Thread(threadTest1);
        Thread t2=new Thread(threadTest2);
        t1.start();
        t2.start();


    }

}

当sycnchronized(Person.class)会发现，即使是不同的两个person对象也会按照顺序来同步执行。当sycnchronized(o1)的时候会发现只有统一person对象才会同步，不同的person对象不会发生同步的行为。

ps:如果错误或者意见欢迎大家留言 打脸 哈哈