浅析Java 多线程中的锁

84 篇文章 2 订阅
44 篇文章 2 订阅

在这里插入图片描述

前言

随着互联网技术的快速发展,多线程编程已经成为了现今编程领域中必不可少的知识点之一。Java 是一种广泛使用的编程语言,也是一些底层应用程序和高并发应用程序的首选语言。而 Java 提供的多线程编程机制和相关的锁机制,则成为了 Java 开发人员分析和解决并发问题的重要工具。
在本文中,我们将重点探讨 Java 多线程中的锁机制,包括锁的类型,锁的实现方法,锁的应用场景,以及锁的缺陷和解决方法。希望通过本文的介绍,读者能够更加深入地理解并掌握 Java 多线程编程的相关知识和技巧。

一、Java 中的锁类型

Java 中的锁主要分为两种类型,即对象锁和类锁。对象锁是用来锁定某个对象实例的,类锁是用来锁定整个类的。下面我们将对这两种锁进行详细介绍。

1. 对象锁

对象锁,也称为实例锁,是用来锁定某个对象实例的。在 Java 中,每个对象都有一个独特的锁或监视器,当线程进入某个被锁定的对象实例的同步代码块时,它必须先获得对象的锁,才能执行同步代码块中的代码。当一个线程已经持有了某个对象的锁,其他线程就不能再获得该对象的锁,直到持有锁的线程退出同步代码块或方法,释放锁为止。
Java 中有两种实现对象锁的方式:synchronized 和 Lock 接口。
synchronized 关键字是 Java 中最简单的实现对象锁的方式。它可以用来修饰方法或代码块,在修饰的方法或代码块执行时,会自动获取对象锁,并在执行完成后释放锁。当 synchronized 关键字接在方法前面时,所有加锁的代码块都会自动加上 this 对象锁。当 synchronized 关键字接在代码块前面时,需要显式指定锁对象。
Lock 接口是 Java 中更加灵活的实现对象锁的方式。与 synchronized 关键字不同,Lock 接口可以用于锁定的实例不一定是 this,可以是任何对象。在使用 Lock 接口时,线程需要显式地获得锁,并在代码块完成后显式释放锁。这种方式可以更好地控制锁的粒度,减少不必要的等待时间和竞争。

public class Counter {
  private int count = 0;
  //对象锁
  public synchronized void increment() {
    count++;
  }
  public int getCount() {
    return count;
  }
}
public class Main {
  public static void main(String[] args) throws InterruptedException {
    Counter counter = new Counter();
    Thread thread1 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) {
        counter.increment();
      }
    });
    Thread thread2 = new Thread(() -> {
      for (int i = 0; i < 1000; i++) {
        counter.increment();
      }
    });
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println("Count: " + counter.getCount());
  }
}

2. 类锁

类锁是用来锁定整个类的。类锁在 Java 中与对象锁的区别在于,类锁只能锁定一个类的所有实例,而不是某个具体的实例。当一个线程获得了锁,该类的所有实例都不能被其他线程使用,直到释放锁为止。
在 Java 中,实现类锁可以使用 synchronized 关键字。当 synchronized 关键字接在一个静态方法或静态代码块前面时,它会锁定整个类。这样所有的实例都会被锁定,所有的非静态代码块则无法访问。

public class Counter {
private static int count = 0;
//类锁
public static synchronized void increment() {
    count++;
}
public static int getCount() {
    return count;
 }
}
public class Main {
public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            Counter.increment();
        }
    });
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            Counter.increment();
        }
    });
    thread1.start();
    thread2.start();
    thread1.join();
    thread2.join();
    System.out.println("Count: " + Counter.getCount());
}
}

在这里插入图片描述

二、锁的实现方法

Java 中的锁机制的实现主要有两种方式:悲观锁和乐观锁。悲观锁指的是,在访问共享资源之前,我们先要获取锁,保证资源在代码块中的一致性。而乐观锁则是指,我们在访问共享资源时,不会加锁来保证资源的一致性。

1. 悲观锁

Java 中,synchronized 和 Lock 接口均采用了悲观锁机制,即在访问共享资源之前,先要获取锁,确保资源在代码块中的一致性。悲观锁对并发效率有一定的影响,因为当线程在等待获取锁时,会影响其他线程的运行。但悲观锁也更加稳定可靠,能够在高并发环境下保证数据安全。
悲观锁示例代码(使用 synchronized 关键字):

public class SynchronizedDemo {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

以上代码演示了如何使用 synchronized 关键字实现悲观锁。在 increment() 方法和 getCount() 方法上都添加了synchronized 关键字,这样在对 count 进行操作时就会获得锁,以保证并发访问不会产生数据混乱。

2. 乐观锁

乐观锁主要用于无锁编程的场景,通常使用基于 CAS 操作的算法实现。CAS(Compare and Swap)是指在操作之前先比较共享变量和期望值,如果相等,则执行操作;否则,不做任何操作。因此,CAS 操作不需要加锁,可以提高并发执行的效率。

乐观锁示例代码(使用 AtomicInteger):

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerDemo {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
    public int getCount() {
        return count.get();
    }
}

以上代码演示了如何使用 AtomicInteger 类实现乐观锁。AtomicInteger 类提供了多个原子操作方法,其中 incrementAndGet() 方法可以实现对计数器的原子操作,而不需要使用锁。这样可以避免由于并发访问而导致的数据混乱。

在这里插入图片描述

三、锁的应用场景

Java 中的锁机制主要应用于多线程编程中,它的应用场景可以分为以下两种:

1. 同步代码块和同步方法

同步代码块和同步方法主要用于保证并发访问安全,避免数据混乱或不一致。在访问一个共享资源时,使用锁机制来控制资源的访问顺序,禁止其他线程同时访问,从而保证资源能够被正确访问。

2. 死锁解决

死锁指的是两个或多个进程在执行某个共享资源时,因为互相等待对方的行为而陷入一种无限等待的状态。当多个线程占用同一个锁时,就会产生死锁问题。为了解决死锁问题,Java 提供了一些机制,如 wait()、notify()、notifyAll() 等,通过精细地控制锁的释放和通知,来协调各个线程的执行。
死锁:

public class Deadlock {
public static void main(String[] args) {
    Object object1 = new Object();
    Object object2 = new Object();
    Thread thread1 = new Thread(() -> {
        synchronized (object1) {
            System.out.println("Thread 1: Holding lock 1...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (object2) {
                System.out.println("Thread 1: Holding lock 1 & 2...");
            }
        }
    });
    Thread thread2 = new Thread(() -> {
        synchronized (object2) {
            System.out.println("Thread 2: Holding lock 2...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2: Waiting for lock 1...");
            synchronized (object1) {
                System.out.println("Thread 2: Holding lock 1 & 2...");
            }
        }
    });
    thread1.start();
    thread2.start();
}
}

解决死锁:

public class Deadlock {
private static Object object1 = new Object();
private static Object object2 = new Object();
public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new Thread(() -> {
        synchronized (object1) {
            System.out.println("Thread 1: Holding lock 1...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (object2) {
                System.out.println("Thread 1: Holding lock 1 & 2...");
            }
        }
    });
    Thread thread2 = new Thread(() -> {
        synchronized (object1) {
            System.out.println("Thread 2: Holding lock 1...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2: Waiting for lock 2...");
            synchronized (object2) {
                System.out.println("Thread 2: Holding lock 1 & 2...");
            }
        }
    });
    Thread thread3 = new Thread(() -> {
        synchronized (object2) {
            System.out.println("Thread 3: Holding lock 2...");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 3: Waiting for lock 1...");
            synchronized (object1) {
                System.out.println("Thread 3: Holding lock 1 & 2...");
            }
        }
    });
    thread1.start();
    thread2.start();
    thread3.start();
    thread1.join();
    thread2.join();
    thread3.join();
    System.out.println("All threads completed execution!");
}
}

在这里插入图片描述

四、锁的缺陷和解决方法

Java 中的锁机制虽然可以保护共享资源,避免数据混乱,但也存在一些缺陷。例如,锁的粒度控制不好,容易产生线程饥饿和死锁问题,降低程序运行效率。为了解决这些问题,我们可以采用以下方法:

1. 减少同步块的代码量

锁定代码块时,应该尽量减少同步代码块的代码量,将同步代码块中的操作分解成多个独立的部分,只锁定需要锁定的部分。

Java中可以通过使用Lock接口来代替synchronized关键字,从而减少同步块的代码量。

以下是使用Lock接口实现同步的示例代码:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo {
    private Lock lock = new ReentrantLock();

    public void doSomething() {
        lock.lock();
        try {
            // 在这里放置需要同步的代码块
        } finally {
            lock.unlock();
        }
    }
}

在上面的代码中,lock.lock()获取锁,lock.unlock()释放锁,将需要同步的代码放在锁内部即可。

synchronized关键字相比,使用Lock接口的优点包括:

  • 可以手动控制锁的获取和释放。
  • 支持可重入特性和公平锁特性。
  • 可以对锁进行更加细粒度的控制。
  • 可以在等待锁的时候响应中断,避免死锁。

但需要注意的是,在使用Lock接口时,如果未手动控制锁的获取和释放将会导致死锁的风险,因此需要特别小心。

2. 使用 ReentrantLock 类

Java 中,Lock 接口提供了 ReentrantLock 类,它可以使用 tryLock() 和 tryLock(long timeout, TimeUnit unit) 方法,来尝试获得锁,并且支持手动解锁,可以更加灵活地控制锁的粒度和锁的释放。

好的,以下是一个使用ReentrantLock实现的简单多线程示例程序:

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    public static void main(String[] args) {

        // 创建一个公共资源
        Resource resource = new Resource();

        // 创建两个线程,同时对公共资源进行操作
        new Thread(new MyThread("Thread-1", resource)).start();
        new Thread(new MyThread("Thread-2", resource)).start();
    }

    // 自定义线程类
    static class MyThread implements Runnable {

        private String name;
        private Resource resource;

        public MyThread(String name, Resource resource) {
            this.name = name;
            this.resource = resource;
        }

        @Override
        public void run() {
            try {
                // 加锁
                resource.lock();
                // 操作公共资源
                System.out.println("Thread " + name + " is using the resource.");
                Thread.sleep(1000);
                // 解锁
                resource.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 公共资源类
    static class Resource {

        private ReentrantLock lock = new ReentrantLock();

        public void lock() {
            lock.lock();
        }

        public void unlock() {
            lock.unlock();
        }
    }
}

在这个示例程序中,我们创建了一个公共资源类Resource,并在其中使用ReentrantLock创建了一个锁。同时,在MyThread线程类中,我们在操作公共资源之前和之后使用lock()unlock()方法来对锁进行加锁和解锁。这样,在同一时间只有一个线程可以对公共资源进行操作,从而保证了并发访问的正确性。

运行程序后,可以看到控制台输出的结果类似于:

Thread Thread-1 is using the resource.
Thread Thread-2 is using the resource.

说明两个线程轮流对公共资源进行了操作。

3. 使用锁的分段技术

锁的分段技术可以将共享资源分成多个部分,每个部分使用一个独立的锁来控制并发访问。这样可以提高锁的粒度,减少线程等待时间。
分段技术是一种在并发情况下提高性能的方式,它的核心思想是将锁细化为多个部分,而非所有的资源都需要被锁定,这样就可以提高并发度。Java提供了ConcurrentHashMap来实现这种分段技术。

下面是一个使用分段锁技术的简单示例:

public class ConcurrentMapDemo {

    private final int segmentCount;
    private final Map<Integer, String>[] segments;

    public ConcurrentMapDemo(int parallelism) {
        this.segmentCount = parallelism;
        this.segments = new ConcurrentHashMap[parallelism];
        for (int i = 0; i < parallelism; i++) {
            segments[i] = new ConcurrentHashMap<>();
        }
    }

    private int getSegmentIndex(Object key) {
        return Math.abs(key.hashCode() % segmentCount);
    }

    public String put(Object key, String value) {
        int segmentIndex = getSegmentIndex(key);
        Map<Integer, String> segment = segments[segmentIndex];
        synchronized (segment) {
            return segment.put(key.hashCode(), value);
        }
    }

    public String get(Object key) {
        int segmentIndex = getSegmentIndex(key);
        Map<Integer, String> segment = segments[segmentIndex];
        synchronized (segment) {
            return segment.get(key.hashCode());
        }
    }
}

在上述示例中,ConcurrentMapDemo类中有一个segments数组,它包含了多个ConcurrentHashMap实例。而getSegmentIndex()方法会根据key的hashcode将其映射到对应的ConcurrentHashMap实例上。为了保证线程安全,对于访问同一个ConcurrentHashMap实例的操作会采用synchronized关键字进行保护。这样,不同的线程访问不同的ConcurrentHashMap实例时就不会相互阻塞。

总之,分段锁技术可以有效提高并发性,避免线程互相等待,提高性能。

4. 优化同步代码块内的数据结构

Java 中,同步代码块中的数据结构对锁的短暂持有时间有很大影响。使用优化的数据结构(如 ConcurrentHashMap、ConcurrentLinkedQueue 等)可以有效减小同步代码块的持有时间,提高运行效率。
在Java中对同步代码块进行优化,可以通过减小同步代码块的作用域和利用读写锁(ReadWriteLock)等方式实现。下面是一个示例,通过利用分段锁(Segment Locking)技术对数据结构进行优化。

public class ConcurrentMapOptimized<K, V> {

    private final int segmentCount; 
    private final Map<K, V>[] segments; 
    private final ReentrantLock[] locks; 

    public ConcurrentMapOptimized(int parallelism) {
        this.segmentCount = parallelism;
        this.segments = new HashMap[parallelism];
        this.locks = new ReentrantLock[parallelism];
        for (int i = 0; i < parallelism; i++) {
            segments[i] = new HashMap<>();
            locks[i] = new ReentrantLock();
        }
    }

    private int getSegmentIndex(K key) {
        return Math.abs(key.hashCode() % segmentCount);
    }

    public V get(K key) {
        int segmentIndex = getSegmentIndex(key);
        try {
            locks[segmentIndex].lock();
            return segments[segmentIndex].get(key);
        } finally {
            locks[segmentIndex].unlock();
        }
    }

    public void put(K key, V value) {
        int segmentIndex = getSegmentIndex(key);
        try {
            locks[segmentIndex].lock();
            segments[segmentIndex].put(key, value);
        } finally {
            locks[segmentIndex].unlock();
        }
    }

    public void remove(K key) {
        int segmentIndex = getSegmentIndex(key);
        try {
            locks[segmentIndex].lock();
            segments[segmentIndex].remove(key);
        } finally {
            locks[segmentIndex].unlock();
        }
    }
}

在上述示例中,我们使用分段锁(Segment Locking)技术对数据结构进行了优化。具体来说,我们将整个Map分为了多个Segment,每个Segment占用一把ReentrantLock。这样,每个操作只需要在自己所在的Segment中获取锁,而不需要在所有Segment上都进行锁定。这样就可以减小同步代码块的范围,提高效率。

在这里插入图片描述

总结

补充一点,在使用锁时,我们也应该注意锁的粒度和锁定顺序。锁的粒度越小,锁定的时间就越短,竞争的线程就越少,从而提高并发效率。同时,锁的锁定顺序也会影响并发效率。当多个线程都需要获取多个锁时,如果锁定顺序不同,就可能出现死锁问题。因此,我们需要遵循一定的锁定顺序,尽可能减少死锁的出现。
Java 中的锁机制是保证并发访问安全的重要工具。本文详细介绍了 Java 中的锁类型、锁的实现方法、锁的应用场景,以及锁的缺陷和解决方法。在使用锁时,我们需要根据实际的业务场景和运行环境,选择恰当的锁类型和实现方式。同时,我们也要注意锁的粒度,尽量缩小锁的持有时间,提高程序的运行效率。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值