多线程：线程同步

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a18826132770/article/details/78091121
版权
一、线程安全问题

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码，如果程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

多线程安全问题，是由于多个线程在访问共享的资源，并且操作共享资源的语句不止一条，那么在多条操作共享资源之间的线程可能发生切换。只要切换就会产生安全问题。

下面举个银行取款的例子：

先编写一个账户类Account：

public class Account {
	private String accountNo;
	private double balance;

	public Account(String accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}

	@Override
	public int hashCode() {
		return accountNo.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		return true;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public void withdraw(double drawAccount) {
		if (getBalance() >= drawAccount) {
			System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");
			setBalance(getBalance() - drawAccount);
			System.out.println("\t余额为：" + getBalance() + "元！");
		} else {
			System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");
		}
	}
}
再编写模拟取款操作的线程DrawThread： 
public class DrawThread extends Thread {
	private Account account;
	private double drawAccount;
	
	public DrawThread(String name, Account account, double drawAccount) {
		super(name);	//设置线程名
		this.account = account;
		this.drawAccount = drawAccount;
	}
	
	public void run() {
		account.withdraw(drawAccount);
	}
}
最后编写测试类DrawTest： 
public class DrawTest {

	public static void main(String[] args) {
		Account account = new Account("账户", 1000);
		// 模拟两个线程对同一个账户取钱
		new DrawThread("张三", account, 800).start();
		new DrawThread("李四", account, 800).start();
	}
}

运行结果：

李四取款成功！取出：800.0元！
张三取款成功！取出：800.0元！
	余额为：200.0元！
	余额为：-600.0元！

运行后发现结果出现错误，这是因为多线程调度的不确定性，使两个线程同时操作共享资源引起的。

二、同步代码块

为了解决上面出现的问题，java的多线程引用同步监视器来解决这个问题。java有两种线程同步机制：1.同步代码块；2.同步方法。

同步代码块的语法格式如下：

synchronized (锁对象) {
    可能会产生线程安全问题的代码
}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

下面使用同步代码块来修改Account的withdraw（）方法

public class Account {
	private String accountNo;
	private double balance;
	private Object obj = new Object(); // 作为同步监视器

	public Account(String accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}

	@Override
	public int hashCode() {
		return accountNo.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		return true;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public void withdraw(double drawAccount) {
		synchronized (obj) {
			if (getBalance() >= drawAccount) {
				System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");
				setBalance(getBalance() - drawAccount);
				System.out.println("\t余额为：" + getBalance() + "元！");
			} else {
				System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");
			}
		}
	}

}

运行结果：

张三取款成功！取出：800.0元！
	余额为：200.0元！
李四取钱失败！余额不足！

运行结果正确，但明显感觉运行时间变长

三、同步方法

同步代码块的语法格式如下：

public synchronized void method() {
    可能会产生线程安全问题的代码
}

同步方法中的锁对象是 this

下面使用同步方法来修改Account的withdraw（）方法

package demo.sync.method;

public class Account {
	private String accountNo;
	private double balance;
	private Object obj = new Object(); // 作为同步监视器

	public Account(String accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}

	@Override
	public int hashCode() {
		return accountNo.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		return true;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public synchronized void withdraw(double drawAccount) {
		if (getBalance() >= drawAccount) {
			System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");
			setBalance(getBalance() - drawAccount);
			System.out.println("\t余额为：" + getBalance() + "元！");
		} else {
			System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");
		}
	}
}

运行结果与同步代码块的结果一样

四、同步锁（Lock接口）

从Java5开始，Java提供一种功能更强大的线程同步机制——通过显示定义同步锁对象来实现同步，在这种机制下，同步锁由Lock对象充当。

虽然 synchronized 方法和语句的范围机制使得使用监视器锁编程方便了很多，而且还帮助避免了很多涉及到锁的常见编程错误，但有时也需要以更为灵活的方式使用锁。

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

public class Account {
	private String accountNo;
	private double balance;
	// 定义可重入的互斥锁对象
	private final Lock lock = new ReentrantLock();

	public Account(String accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}

	@Override
	public int hashCode() {
		return accountNo.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Account other = (Account) obj;
		if (accountNo == null) {
			if (other.accountNo != null)
				return false;
		} else if (!accountNo.equals(other.accountNo))
			return false;
		return true;
	}

	public double getBalance() {
		return balance;
	}

	public void setBalance(double balance) {
		this.balance = balance;
	}

	public void withdraw(double drawAccount) {
		lock.lock();	// 加锁
		try {
			if (getBalance() >= drawAccount) {
				System.out.println(Thread.currentThread().getName() + "取款成功！取出：" + drawAccount + "元！");
				setBalance(getBalance() - drawAccount);
				System.out.println("\t余额为：" + getBalance() + "元！");
			} else {
				System.out.println(Thread.currentThread().getName() + "取钱失败！余额不足！");
			}
		} finally {			// 使用finally来保证一定会释放锁
			lock.unlock();	//释放锁
		}
	}
}

运行结果同上。

五、死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

产生死锁的四个必要条件：

  •  互斥条件：一个资源每次只能被一个进程使用。 
  •  请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  •  不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
  •  循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
public class DeadLock extends Thread {
	LockA a = new LockA();
	LockB b = new LockB();

	public static void main(String[] args) {
		DeadLock d = new DeadLock();
		d.start();
		d.init();
	}

	public void run() {
		b.first(a);
		System.out.println("进入" + Thread.currentThread().getName() + "之后");
	}

	public void init() {
		a.first(b);
		System.out.println("进入" + Thread.currentThread().getName() + "之后");
	}
}

class LockA {
	public synchronized void first(LockB b) {
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入A的frist方法");
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "准备调用B的last方法");
		b.last();
	}

	public synchronized void last() {
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入A的last方法");
	}
}

class LockB {
	public synchronized void first(LockA a) {
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入B的frist方法");
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "准备调用A的last方法");
		a.last();
	}

	public synchronized void last() {
		System.out.println("当前线程名：" + Thread.currentThread().getName() + "进入B的last方法");
	}
}

运行结果：

当前线程名：main进入A的frist方法
当前线程名：Thread-0进入B的frist方法
当前线程名：main准备调用B的last方法
当前线程名：Thread-0准备调用A的last方法

由结果可以看出main线程获得A锁后想要获取B锁，Thread-0获得B锁想要获取A锁，但两个线程都不肯放开资源，所以处于死锁状态，运行后可以看到程序一直处于运行状态。

注意：

1.多个线程想保证线程安全，必须要使用同一个锁对象.

  • 同步代码块
synchronized (锁对象) {
    可能会产生线程安全问题的代码
}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

  • 同步方法
public synchronized void method() {
    可能会产生线程安全问题的代码
}

同步方法中的锁对象是 this

  • 静态同步方法

public static synchronized void method() {
    可能会产生线程安全问题的代码
}

同步方法中的锁对象是 本类类名.class


2.不可变类总是线程安全的，因为它的对象状态不可；但可变对象需要额外的方法来保证其线程安全。

可变类的线程安全是以降低程序的运行效率作为代价的，为了减少线程安全所带来的负面影响，程序可以采用一下策略：

  • 不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源的方法 进行同步。
  • 如果可变类有两种运行环境：单线程环境和多线程环境，则需要为该可变类提供两个版本，即线程安全版本和线程不安全版本。例如JDK所提供的StringBuffer、StringBuilder就是为了解决不同环境所提供的类，在单线程环境下应该使用StringBuilder来保证较好的性能；但需要保证多线程安全的时候就使用StringBuffer。

3.为了保证同步锁一定会释放，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。在大多数情况下，应该使用以下语句：

     Lock l = ...; 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

4.线程在如下几种情况释放同步监视器：

  • 当前线程的同步方法、同步代码块执行结束。
  • 当前线程在同步方法、同步代码块中遇到break、return终止了该代码块、该方法继续运行。
  • 当前线程在同步方法、同步代码块中出现了未处理的error或Exception，导致该代码块、该方法异常结束时。
  • 当前线程执行同步方法、同步代码块时，程序执行了同步监视器对象的wait()方法，则当前线程暂停。

线程在如下几种情况不会释放同步监视器：

  • 线程执行同步代码块或同步方法时，程序调用Thread .sleep()、Thread.yield()方法来暂停当前线程的执行时。
  • 线程执行同步代码块或同步方法时，其他线程调用了该线程的suspend()方法将该线程挂起。（程序应尽量避免使用suspend()和resume()方法来控制线程）


JASS-
关注
专栏目录
Java多线程：线程同步详解
流楚丶格念的博客
07-16 3127
线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。
多线程时，线程同步的两种方法简单介绍
u010698072的博客
11-20 2944
在典型的卖票程序中，需要考虑多个窗口买票时的数据同步问题，对此可能需要线程同步，下面简单介绍下两种同步方法； Demo：public static void main(String[] args) { ThickesRunnable tr = new ThickesRunnable();//实现Runnable接口 Thread t1 = new Thread(tr
Java多线程同步问题:一个小Demo完全搞懂
weixin_30292843的博客
01-17 136
版权声明：本文出自汪磊的博客，转载请务必注明出处。 Java线程系列文章只是自己知识的总结梳理，都是最基础的玩意，已经掌握熟练的可以绕过。 一、一个简单的Demo引发的血案 关于线程同步问题我们从一个简单的Demo现象说起。Demo特别简单就是开启两个线程打印字符串信息。 OutPutStr类源码： 1 public class OutPutStr { 2 3 publ...
多线程：控制线程
a18826132770的博客
09-28 206
一、后台线程（守护线程）
解决线程同步问题
一步一脚印的博客
08-18 450
首先我们应该先来了解什么是线程安全问题？ 给定一个进程内的所有线程，都共享同一存储空间，这样有好处又有坏处。这些线程就可以共享数据，非常有用。不过，当多个线程同时访问，修改同一资源时，可能会造成数据异常问题，就会造成线程安全问题。因此，Java 提供了同步机制，以控制对共享资源的互斥访问。 线程同步： 就是多个线程按一定顺序执行； 即多个线程排成队列，当拿到锁资源的线程就开始执行； 线程同步的实现可以借助Synchronized关键字，ReentrantLock类，ThreadLocal类。 s
线程同步
buaawhl的专栏
02-25 666
线程同步 作者 : buaawhl 我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程（Thread）。 线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。 当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到...
Java多线程-同步机制解决线程安全问题方式一：同步代码块
01-29
Java多线程编程中，线程安全问题是常见的挑战，特别是在并发环境下，多个线程可能会同时访问和修改同一份共享资源，导致数据不一致。为了解决这个问题，Java提供了同步机制，其中一种常用的方式就是同步代码块...
Java 多线程技术：（四）获取线程基本信息_暂停线程_线程的优先级_多线程的安全性_线程同步
12-20
5. 线程同步： 线程同步是解决多线程并发问题的关键。Java提供了以下机制： - `synchronized` 关键字：如上所述，用于实现互斥访问，防止多个线程同时进入临界区。 - `wait()`, `notify()`, `notifyAll()`：这些...
使用三种VC的多线程同步方法编写一个多线程的程序
04-03
1.使用三种VC的多线程同步方法编写一个多线程的程序（要求在屏幕上先显示Hello，再显示World）。 1）基于全局变量的多线程同步程序； 2）基于事件的多线程同步程序； 3）基于临界区的多线程同步程序。
多线程：C#线程同步lock,Monitor,Mutex,同步事件和等待句柄[整理].pdf
10-12
多线程：C#线程同步lock,Monitor,Mutex,同步事件和等待句柄[整理].pdf
请说出你所知道的线程同步的方法。_多线程同步的五种方法，让你全面了解线程同步...
weixin_39854951的博客
01-18 214
一、为什么要线程同步 因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线...
让多线程按顺序执行的几种方法
热门推荐
Jqcode
09-05 1万+
文章介绍4种方法，简单易懂，通过4个demo抛砖引玉。 目录 在子线程中通过join()方法指定顺序 在主线程中通过join()方法指定顺序 通过倒数计时器CountDownLatch实现 通过创建单一化线程池newSingleThreadExecutor()实现 在子线程中通过join()方法指定顺序 通过join()方法使当前线程“阻塞”，等待指定线程执行完毕后继续执行。举例：在...
实现线程同步的几种方式
htflll的博客
01-10 7928
在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行，虽然说可以通过线程的优先权进行设置，但是他只是获取CUP执行权的概率高点，但是也不一定必须先执行。在这种情况下如何保证线程按照一定的顺序进行执行，今天就来一个大总结，分别介绍一下几种方式。 1.通过Object的wait和notify 2.通过Condition的awiat和signal 3.通过一个阻塞队列 4.通过两个阻塞队列 5.通过SynchronousQueue 6.通过线程池的Callback回调 7.通过同步辅助类Coun
线程同步问题
weixin_45012273的博客
10-17 376
什么是线程同步和互斥??? 如果你编写的是多线程的程序,那么多个线程的并发执行,可以认为他们是同时执行代码的,但是线程和线程之间并非是毫无关系的,很多时候会有以下的两种关系: a) 线程A的继续执行 要以线程B完成了某一个操作后为前提,这种称为线程同步 b) 多个线程不可同时修改一个资源(全局变量 ,数据结构,对象),这种称为线程的互斥 为什么需要线程同步和互斥 线程同步: // 09_线程同步的问题.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #incl
多线程之线程同步
奔走的王木木Sir的博客
08-05 570
线程同步（一）、并发，线程同步，队列，锁（二）、三大不安全案例（三）、同步方法与同步块1.同步方法2.同步块3.扩充JUC（四）、死锁（五）、Lock（锁） （一）、并发，线程同步，队列，锁 并发：同一个对象被多个线程同时操作 线程同步：现实中遇到同一个资源多个人都想使用。 ​ 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入和这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程再使用。
java 对象锁是什么_Java锁到底锁的到底是哪个对象？什么是锁对象
weixin_42515409的博客
02-13 1793
一直对多线程有点迷糊，不知道什么是锁对象，锁的到底是个什么玩意，最近看了下面这位大佬的解释，感觉很到位一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在Java里 边就是拿到某个同步对象的锁(一个对象只有一把锁)；如果这个时候同步对象的锁被其他线程拿走了，他(这个线程)就只能等了(线程阻塞在锁池等待队列 中)。取到锁后，他就开始执行同步代码(被synchro...
spring事务详细讲解-深入浅出
小电玩
09-08 490
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1476
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 546
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java多线程：线程同步与异步深度解析
在Java程序设计中，理解和掌握线程同步与异步的概念是至关重要的，尤其是在进行多线程程序设计时。线程同步和异步主要涉及如何管理和协调多个线程间的执行顺序和数据访问。 线程同步是指在多线程环境下，为了确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值