版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/JY_He/article/details/79669987
主要理清锁的使用和本质锁的是什么：
synchronized：
synchronized是java中的一个关键字，在JVM层面上实现的，使用时不需要管理锁的获取和释放。（synchronized发生异常时，会自动释放线程占有的锁）
直接上代码：
public class SynchronziedTest implements Runnable{
//非静态属性
private int num;
//非静态属性,加了volatile关键字（1.该值直接刷新到主存，2.禁止jvm指令重排）
private volatile int count;
////静态属性
private static int other;
//静态属性
private static int changme = 0;
//静态属性，同时加上volatile关键字
private static volatile int sum;
//类的静态属性
private static final Object obj = new Object();
//据说，此锁更可提高性能。源于：锁的对象越小越好
private static byte block[] = {};
//方法上加同步，用的对象锁：锁住的是当前对象，不同对象操作时，线程不安全
public synchronized void addNum(){
num++;
}
//非静态方法中的代码块加同步
public void addCount(){
//锁住的是当前对象的类对象
synchronized (this.getClass()){
count+=2;
}
}
//非静态方法中的代码块加同步，锁的是类的静态成员属性
public void mulCount(){
synchronized (SynchronziedTest.obj){
count-=1;
}
}
//非静态方法中的代码块加同步
public void addOther(){
//锁住的是当前对象的类对象
synchronized (this.getClass()){
other+=2;
}
}
//非静态方法中的代码块加同步，锁的是类的静态成员属性（属性必须被static以及final修饰，否则报错）
public void mulOther(){
synchronized (SynchronziedTest.obj){
other-=1;
}
}
//静态方法加同步，对静态变量进行操作,锁的是当前类对象
public synchronized static void addchangme(){
changme+=5;
}
//静态方法中静态代码块加同步，对静态变量chanme进行操作
public static void mulchangme(){
//同步锁锁住的是该类的静态成员属性
synchronized (SynchronziedTest.block){
for (int i=0;i<2;i++){
changme-=1;
}
}
}
//非静态方法加同步，操作静态属性
public synchronized void sum(){
sum+=10;
}
//非静态方法
public void mulSum(){
//代码块上加同步，操作静态属性
synchronized (SynchronziedTest.class){
for (int i=0;i<3;i++){
sum-=1;
}
}
}
public void printer(){
//计划值为2：实际值为1：，即同步没有生效
System.out.println(Thread.currentThread().getName()+" num值为： " + num);
//计划值为：实际值为1：，即同步没有生效
System.out.println(Thread.currentThread().getName()+" count值为： " + count);
//计划值为2：实际值为2：，即同步生效
System.out.println(Thread.currentThread().getName()+" other值为： " + other);
//计划值为6：实际值为6：，即同步生效
System.out.println(Thread.currentThread().getName()+" changme值为： " + changme);
//计划值为14：实际值为14：，即同步生效
System.out.println(Thread.currentThread().getName()+" sum值为: " + sum);
}
@Override
public void run() {
addNum();
addCount();
mulCount();
addOther();
mulOther();
addchangme();
mulchangme();
sum();
mulSum();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
printer();
}
}
public class Test {
public static void main(String[] args) {
Thread t1 = new Thread(new SynchronziedTest(),"线程1");
Thread t2 = new Thread(new SynchronziedTest(),"线程2");
t1.start();
t2.start();
}
}
运行结果：
线程2 num值为： 1
线程2 count值为： 1
线程2 other值为： 2
线程2 changme值为： 6
线程2 sum值为: 14
线程1 num值为： 1
线程1 count值为： 1
线程1 other值为： 2
线程1 changme值为： 6
线程1 sum值为: 14
确保多线程操作的资源是同一资源两种方式：单列（确保同一对象）/static关键字（确保类的同一属性）
Lock：
Lock是一个接口，通过代码实现，使用时候需要手动进行锁的释放，如果没有主动释放，很容易造成死锁（需要在finally块中释放锁）
直接上代码：
public class LockTest implements Runnable{
//非静态属性
private int num;
//非静态属性
private int A;
//非静态属性
private int B;
//非静态属性,加了volatile关键字（1.该值直接刷新到主存，2.禁止jvm指令重排）
private volatile int count;
////静态属性
private static int other;
//静态属性
private static int changme = 0;
//静态属性，同时加上volatile关键字
private static volatile int sum;
//非静态锁
private Lock lock1 = new ReentrantLock();
//静态锁
private static Lock lock2 = new ReentrantLock();
public void addNum(){
Lock lock3 = new ReentrantLock();
lock3.lock();
try {
for (int i = 0;i<5;i++){
num++;
}
}finally {
lock3.unlock();
}
}
public void mulNum(){
Lock lock3 = new ReentrantLock();
lock3.lock();
try {
num--;
}finally {
lock3.unlock();
}
}
public void addCount(){
lock1.lock();
try {
count+=2;
}finally {
lock1.unlock();
}
}
public void mulCount(){
lock1.lock();
try {
count-=1;
}finally {
lock1.unlock();
}
}
public void addOther(){
lock2.lock();
try{
other+=2;
}finally {
lock2.unlock();
}
}
public void mulOther(){
lock2.lock();
try{
other-=1;
}finally {
lock2.unlock();
}
}
public static void addchangme(){
lock2.lock();
try{
changme+=5;
}finally {
lock2.unlock();
}
}
public static void mulchangme(){
lock2.lock();
try{
for (int i=0;i<2;i++){
changme-=1;
}
}finally {
lock2.unlock();
}
}
public void sum(){
lock2.lock();
try{
for (int i=0;i<2;i++){
sum+=10;
}
}finally {
lock2.unlock();
}
}
public void mulSum(){
lock2.lock();
try{
for (int i=0;i<3;i++){
sum-=1;
}
}finally {
lock2.unlock();
}
}
public void addA(){
lock2.lock();
try {
for (int i = 0;i<3;i++){
A++;
}
}finally {
lock2.unlock();
}
}
public void mulA(){
lock2.lock();
try {
A--;
}finally {
lock2.unlock();
}
}
public void addB(){
lock1.lock();
try {
for (int i = 0;i<3;i++){
B++;
}
}finally {
lock1.unlock();
}
}
public void mulB(){
lock1.lock();
try {
B--;
}finally {
lock1.unlock();
}
}
//多线程操作成功同步条件：
//1.使用的全局锁（Lock为类的静态成员属性）；
//2.对类的全局变量进行操作（类的静态成员属性）；
public void printer(){
//计划值为8：实际值为4：，即同步没有生效
System.out.println(Thread.currentThread().getName()+" num值为： " + num);
//计划值为2：实际值为1：，即同步没有生效
System.out.println(Thread.currentThread().getName()+" count值为： " + count);
//计划值为2：实际值为2：，即同步生效
System.out.println(Thread.currentThread().getName()+" other值为： " + other);
//计划值为6：实际值为6：，即同步生效
System.out.println(Thread.currentThread().getName()+" changme值为： " + changme);
//计划值为34：实际值为34：，即同步生效
System.out.println(Thread.currentThread().getName()+" sum值为: " + sum);
//计划值为4：实际值为2：，即同步不生效
System.out.println(Thread.currentThread().getName()+" A值为: " + A);
//计划值为4：实际值为2：，即同步不生效
System.out.println(Thread.currentThread().getName()+" B值为: " + B);
}
@Override
public void run() {
addNum();
mulNum();
addCount();
mulCount();
addOther();
mulOther();
addchangme();
mulchangme();
sum();
mulSum();
addA();
mulA();
addB();
mulB();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
printer();
}
}
public class Test {
public static void main(String[] args) {
Thread t1 = new Thread(new LockTest(),"线程1");
Thread t2 = new Thread(new LockTest(),"线程2");
t1.start();
t2.start();
}
}
线程1 num值为： 4
线程1 count值为： 1
线程1 other值为： 2
线程1 changme值为： 6
线程1 sum值为: 34
线程1 A值为: 2
线程1 B值为: 2
线程2 num值为： 4
线程2 count值为： 1
线程2 other值为： 2
线程2 changme值为： 6
线程2 sum值为: 34
线程2 A值为: 2
线程2 B值为: 2
确保多线程操作的资源是同一资源两种方式：单列/static关键字
结论：
使用同步锁，一定要搞清楚，需要使用类锁，还是对象锁；如果是不同对象多线程操作同一资源情况，要使用类锁；如果是同一个对象多线程操作同一资源时，需要使用对象锁。具体情况采用相应的锁进行同步问题。