Java之线程同步synchronized和Lock锁

原创已于 2022-03-28 15:00:49 修改 · 2.1k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

于 2022-03-25 18:19:27 首次发布

Java 专栏收录该内容

37 篇文章

订阅专栏

本文详细介绍了线程同步的必要性及实现方式，包括synchronized关键字的多种应用方式和Lock接口的使用方法，并对比了对象锁与类锁的区别，以及Lock锁与synchronized锁的不同之处。

1.为什么需要线程同步？

2.同步处理

2.1synchronized处理同步问题

2.1.1.同步非static的 synchronized方法---对象锁

2.1.2.同步代码块 synchronized (this)---对象锁

2.1.3.同步方法及static的synchronized方法---类锁

2.1.4synchronized（类.class）----类锁

2.1.5synchronized（object）--类锁

2.2Lock锁

3.俩个重要问题：

1.对象锁和类锁的区别

2.Lock锁和synchronized的区别

1.为什么需要线程同步？

观察以下代码的结果：

class  MyThread  implements  Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        for (int i = 0; i <= 10; i++) {
            {
                if (this.ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
// TODO Auto-generated catch block
                        e.printStackTrace();
                    } // 模拟网络延迟
                    System.out.println(Thread.currentThread().getName() + ",还有" + this.ticket-- + " 张票");
                }
            }
        }
    }
}


public class test {
    public static void main(String[] args) {
        MyThread myTread = new MyThread();
        Thread T1 = new Thread(myTread, "黄牛1");
        Thread T2 = new Thread(myTread, "黄牛2");
        Thread T3 = new Thread(myTread, "黄牛3");
        T1.start();
        T2.start();
        T3.start();
    }
}

结果：

这时候看到结果中负数，这种就是不同步操作，多线程并发执行导致的,唯一的好处就是处理速度快。

2.同步处理

2.1synchronized处理同步问题

所谓的同步指的是所有的线程不是一起进入到方法中执行，而是按照顺序一个一个进来。

2.1.1.同步非static的 synchronized方法---对象锁

要使用同步代码块必须设置一个要锁定的对象，所以一般可以锁定当前对象:this，以下实例是一个实例划对象

import static java.lang.Thread.sleep;

//同步方法
class   testThread  implements  Runnable
{
    private  int  ticket=100;

    @Override
    public void run() {
        for (int i=0;i<100;i++)
        {
            try {
                this.sale();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public  synchronized  void  sale() throws InterruptedException {
        if (this.ticket>0)
        {
            sleep(20);
            System.out.println(Thread.currentThread().getName()+"：还有"+this.ticket--+"张票");
        }
    }
}
public class demo {
    public static void main(String[] args) {
        testThread  thread=new testThread();
        Thread  thread1=new Thread(thread,"黄牛1");
        Thread  thread2=new Thread(thread, "黄牛2");
        thread1.start();
        thread2.start();
    }
}

2.1.2.同步代码块 synchronized (this)---对象锁

但是同步方法是在方法里拦截的，也就是说进入到方法中的线程依然可能会有多个。

class  MyTread  implements  Runnable
{
    private int ticket=10;
    @Override
    public void run() {
        for (int i = 0; i <=10; i++) {
            synchronized (this) {
                if (this.ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
// TODO Auto-generated catch block
                        e.printStackTrace();
                    } // 模拟网络延迟
                    System.out.println(Thread.currentThread().getName() + ",还有" + this.ticket-- + " 张票");
                }
            }
        }
    }
}

实际上，synchronized(this)以及非static的synchronized方法，只能防止多个线程同时执行同一个对象的同步代码段。即synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。