动力节点旗下在线教育品牌  |  咨询热线:400-8080-105 学Java全栈,上蛙课网
首页 > 文章

解决多线程访问冲突问题

06-24 19:39 309浏览
举报 T字号
  • 大字
  • 中字
  • 小字

当用多线程访问同一个资源时,非常容易出现线程安全的问题例如当多个线程同时对一个数据进行修改时,会导致某些线程对数据的修改丢失。这也是多线程访问冲突问题如何解决,为了避免同一时刻多个线程访问公共资源,需要采用同步机制来解决这种问题。

下面给大家介绍一些基本的同步机制:

第一种 同步方法

同步方法即使用 synchronized关键字修饰的方法。在Java语言中,每个对象都有一个内置的对象锁与之相关联,该锁会保护整个方法,即对象在任何时候只允许被一个线程所拥有,当一个线程调用对象的一段synchronized代码时,首先需要获得这个锁,然后去执行相应的代码,执行结束,释放锁。synchronized关键字也可以以修饰静态方法,此时如果调用该静态方法,将会锁住整个类。

synchronized关键字主要有两种用法:synchronized方法和synchronized块。此外该关键字还可以作用于静态方法、类或某个实例,但这都对程序的效率有很大的影响。

给一个方法增加synchronized关键字之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的抽象方法。

synchronized方法,在方法的声明前加入synchronized关键字。例如

 1 package com.test.multiThread;

 2

 3 public class Bank {

 4     private int account = 0;

 5

 6     public int getAccount(){

 7         return account;

 8     }

 9     // 同步方法

10     public synchronized void save(int money){

11         this.account += money;

12     }

13 }

14

15 =================================

16

17 package com.test.multiThread;

18

19 public class MyThread implements Runnable {

20     private Bank bank;

21     public MyThread(Bank bank){

22         this.bank = bank;

23     }

24     @Override

25     public void run() {

26         bank.save(1);

27         //bank.save01(1);

28         //bank.save02(1);

29     }

30 }

31

32 =================================

33

34 package com.test.multiThread;

35

36 import java.util.ArrayList;

37

38 public class MultiThreadDemo {

39     public static void main(String[] args) throws InterruptedException {

40         Bank bank = new Bank();

41         System.out.println(bank.getAccount());

42         ArrayList list = new ArrayList<>();

43         for (int i = 0; i < 100000; i++){

44             list.add(new Thread(new MyThread(bank)));

45         }

46         for (Thread thread: list){

47             thread.start();

48         }

49         for (Thread thread: list){

50             thread.join();

51         }

52         System.out.println(bank.getAccount());

53     }

54 }

只要把多线程访问的资源的操作放到multiThreadAccess方法中,就能够保证这个方法在同一时刻只能被一个线程访问,从而保证了多线程访问的安全性。然而当一个方法的方法体规模非常大时,把该方法声明为synchronized会大大影响程序的执行效率。为了提高程序的执行效率,Java语言提供了synchronized块。

第二种 同步代码块

synchronized关键字修饰的语句块。被synchronized修饰的语句块会自动被加上内置锁,从而实现同步。

同步是一种高开销的操作,因此应该尽量减少同步的内容,通常没有必要使用同步方法,使用同步代码块来同步关键代码即可。

可以把任意的代码块声明为synchronized,也可以制定上锁的对象,有非常高的灵活性。用法如下

当使用synchronized来修饰某个共享资源的时候,如果线程Thread01在执行synchronized代码,另外一个线程Thread02也要同时执行同一对象的统一synchronized代码时,线程Thread02将要等到线程Thread01执行成后才能继续执行。在这种情况下,可以使用wait()方法和notify()方法。

synchronized代码被执行期间,线程可以调用对象的wait()方法,释放对象锁,进入等待状态,并且可以调用notify()方法或者notifyAll()方法通知正在等待的而其他线程,notify()唤醒一个线程(等待队列中的第一个线程),并允许它去获得锁,而notifyAll()方法唤醒所有等待这个对象的线程,并允许它们去竞争获得锁。

第三种 使用特殊成员变量(volatile 成员变量)实现线程同步(前提是对成员变量的操作是原子操作)

volatile是一个类型修饰符,被设计用来修饰被不同线程访问和修饰的变量。当变量没有被volatile修饰时,线程读取数据时可能会从缓存中去读取,如果其他线程修改了该变量,则无法读取到修改后的数据。当变量被volatile修饰时,线程每次使用时都会直接到内存中提取,而不会利用缓存,从而保证了数据的同步。

volatile关键字主要目的是放置编译器对代码的优化,使得每次使用数据的时候都从内存里提取,而不是缓存,保证获得的数据是最新被修改的数据。但是volatile不能保证操作的原子性,一般不能替代synchronized代码块,除非对变量的操作是原子操作的情况下才可以使用volatile。

① volatile关键字为成员变量的访问提供了一种免锁机制,但要保证对成员变量的操作是原子操作的情况下才能使用

② volatile关键字相当于告诉虚拟机该成员变量可能会被其他线程修改

③ 每次使用被volatile修饰的成员变量都要从内存提取,重新计算,而不会使用寄存机器中的值

④ volatile不会提供任何原子操作,不能保证线程安全

⑤ volatile不能用来修饰final类型的变量

⑥ 使用volatile会降低程序的执行效率

Java中原子性保证:Java内存模型只保证了基本读取和复制是原子性操作,如果要实现更大范围操作的原子性,可以通过synchronized和Lock保证任一时刻只有一个线程执行该代码,那么自然就不存在原子性问题了,从而保证了原子性。

Java中可见性保证:synchronized和Lock、volatile三种,推荐使用synchronized方式,volatile有局限,适合某个特定场合。

第四种 使用Lock接口(java.util.concurrent.locks包)

JDK5新增了一个java.util.concurrent.locks包来支持同步。该包中提供了Lock接口以及它的一个实现类ReentrantLock(重入锁)

Lock接口也可以用来实现多线程的同步,其提供了如下方法来实现多线程的同步

 

1 public abstract void lock()  // 以阻塞方式来获得锁,即如果获得了锁就立即返回,如果其他线程持有锁,当前线程等待,直到获取锁后返回。当前线程会一直处于阻塞状态,且会忽略interrupt()方法

2 public abstract boolean tryLock()  // 以非阻塞的方式获得锁,即尝试性的去获取锁,如果获得锁就返回true,否则返回false

3 public abstract boolean tryLock(long time, TimeUnit unit)  // 如果在给定时间内获得锁,返回true,否则返回false

4 public abstract void lockInterruptibly  // 如果获得锁,则立即返回,如果没有获得锁,则当前线程会处于休眠状态,直到获得锁,或者当前线程被其他线程中断(会收到InterruptedException异常)。

5 public abstract void unlock  // 释放锁

ReentrantLock类的构造方法

1 public ReentrantLock()  // 创建一个ReentrantLock实例

2 public ReentrantLock(boolean fair)  // 创建公平锁的构造方法,但由于能大幅度降低程序运行效率,不推荐使用

第五种 使用线程局部变量(thread-local)解决多线程对同一变量的访问冲突,而不能实现同步 (ThreadLocal类)

1 public class ThreadLocal

2 extends Object

如果使用ThreadLocal来管理变量,则每一个使用该变量的线程都会获得该变量的副本,副本之间相互独立,这样每一个线程都可以随意修改自己的变量副本,而不会对其他线程产生影响。所以对于同线程对共享变量的操作互不影响。

public class ThreadLocal

extends Object

常用方法

public ThreadLocal()  // 构造方法

public T get()  // 返回次线程局部变量的当前线程副本中的值

public void set(T value)  // 将次线程局部变量的当前线程副本中的值设置为value

protected T initialValue()  // 返回次线程局部变量的当前线程的初始值

public void remove()  //

Thread-local与同步机制的比较:

1)两者都是为了解决多线程中相同变量的访问冲突问题

2)Thread-local采用“空间换时间”方法,同步机制采用“时间换空间”的方式

第六种 使用阻塞队列实现线程同步(java.util.concurrent包)

JDK5提供的java.util.concurrent包中的 Class LinkedBlockingQueue 可以实现线程的同步。

LinkedBlockingQueue是一个基于已连接节点的,范围任意的blocking queue。其常用方法如下:

1 public LinkedBlockingQueue()  //创建一个容量为Interger.MAX_VALUE的LinkedBlockingQueue

2 public int size()  // 返回队列中的元素个数

3 public void put(E e) throws InterruptedException  // 在队尾添加一个元素,如果队列满则阻塞

4 public E take() throws InterruptedException  // 返回并移除对首元素,如果队列空则阻塞

使用阻塞队列实现生产者-消费者。总的来说生产者的速度和消费者的速度相同,但是因为阻塞队列的缘故,不需要控制阻塞,当阻塞对列满的时候,生产者线程就会被阻塞,直到不再满;反之亦然,当消费者线程多于生产者线程时,消费者速度大于生产者速度,当队列为空时,就会阻塞消费者线程,直到队列非空。

第七种 使用原子变量实现线程同步(java.util.concurrent.atomic包)

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作,即这几步要么同时完成,要么都不完成。

JDK5中提供的java.util.concurrent.atomic包中提供了创建原子类型变量的工具类,使用这些工具类能够简化线程同步。

多线程访问冲突的问题不容小觑,需要引起我们足够的重视才能避免出现这种情况。同时,我们要牢牢掌握java多线程的知识,才能在java编程中更加规范,让自己的编程技术趋于完美。

0人推荐
共同学习,写下你的评论
0条评论
明明
程序员明明

3篇文章贡献19624字

作者相关文章更多>

推荐相关文章更多>

Java数据结构

HelloWorld10-31 08:24

浅谈MySQL中SQL优化的常用方法

军哥08-12 23:29

五分钟读懂UML类图

江湖人称小李白12-10 10:41

MyBatis开发框架的四大核心

IT逐梦者08-17 21:43

一次搞定continue,break和return

HelloWorld11-06 11:19

发评论

举报

0/150

取消