JAVA 线程与锁

最新推荐文章于 2023-06-28 09:52:25 发布
最新推荐文章于 2023-06-28 09:52:25 发布
阅读量671 收藏 1
点赞数
分类专栏： java java 并发编程 文章标签： java 多线程 竞争
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingchixin/article/details/36906445
版权

多线程

有时候，我们需要下载文件，使用单线程的时候只能由这个线程进行下载任务，不能完全发挥所有计算机资源，如果我们使用的是多线程的话，那么我们就可以把文件进行分隔，每个线程同时下载文件的一部分，这样就能充分发挥计算机资源，这是多线程中的一个典型应用了。

锁


某些特殊情况下，可能多个线程需要用到计算机的同一个资源，访问这些资源的代码段叫做临界区，这些资源叫做临界资源。比如我们生活中常遇到的存钱和取钱问题，账户里的钱是一个数字，我们不能同时对其进行取和存操作，否则会发生错误。在存的时候不允许进行取钱。取的时候 也不能存钱。这里就用到了锁。 

package test;


public class Demo {
	public int money = 10000;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		// TODO Auto-generated method stub
		Thread t1 = new Thread(new drawmoney());
		Thread t2 = new Thread(new savemoney());
		t1.start();
		t2.start();

	}

	class drawmoney implements Runnable {
		@Override
		public void run() {
			while (true) {
				money--;
				System.out.println("取钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			// TODO Auto-generated method stub

		}

	}

	class savemoney implements Runnable {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				money++;
				System.out.println("存钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}

	}

}
如同上面这个程序按照常理讲结果应该是取钱：9999，然后存钱10000这样交替进行。我们实际运行后会发现不是我们想的这样：结果如下

存钱:10000
取钱:9999
取钱:9999
存钱:10000
存钱:10001
完全乱了。两次取钱都是9999，第一次存钱 应该是10001，也不对

这时候我们该用上传说中的锁了 
package test;

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

public class Demo {
	Lock drawmoney = new ReentrantLock();
	public int money = 10000;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		// TODO Auto-generated method stub
		Thread t1 = new Thread(new drawmoney());
		Thread t2 = new Thread(new savemoney());
		t1.start();
		t2.start();
	}

	class drawmoney implements Runnable {
		@Override
		public void run() {
			while (true) {
				drawmoney.lock();
				money--;
				System.out.println("取钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				drawmoney.unlock();
			}
		}
	}

	class savemoney implements Runnable {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				drawmoney.lock();
				money++;
				System.out.println("存钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				drawmoney.unlock();
			}

		}

	}

}

再看一下加完锁后的运行结果：
取钱:9999
取钱:9998
取钱:9997
取钱:9996
存钱:9997
存钱:9998
存钱:9999
看上去虽然不是交替进行，但这结果确实是对的。这种情况可能是因为取钱的线程是先创建开始 运行的，并且时间片轮转的时候并不能做到平等运行。在这里java也为这种情况提供了解决办法，java中有一个带有公平策略的锁。我们只要去 Lock drawmoney = new ReentrantLock(true);这行代码中加入true这个参数就可以了。
运行结果：
取钱:9999
存钱:10000
取钱:9999
存钱:10000
取钱:9999
存钱:10000
但是这种锁将大大降低性能，所以并不推荐使用。

死锁

如果我们在取钱这个线程里加一个条件，比如说只有钱大于10002时才能取钱 。这时当取钱获得了这个锁并开始进行操作的时候在这里卡住了，而存钱这个线程并没有获得锁又不能进行操作，这时死锁就发生了 
class drawmoney implements Runnable {
		@Override
		public void run() {
			while (true) {
				drawmoney.lock();
				if (money >= 10002) {
					money--;
					System.out.println("取钱:" + money);
				}
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				drawmoney.unlock();
			}
		}
	}

这里的解决办法是用Condition这个类。看名字就知道这是为了新的条件而创造的，当一个线程因为条件不满足而无法继续执行的时候，通过这个条件对象，可是先放弃当前锁，让它加入等待集中，直到能给它有机会来重新满足条件的线程来解除它的阻塞。 
package test;

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

public class Demo {
	Lock drawmoney = new ReentrantLock();
	Condition changed = drawmoney.newCondition();
	public int money = 10000;

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		// TODO Auto-generated method stub
		Thread t1 = new Thread(new drawmoney());
		Thread t2 = new Thread(new savemoney());
		t1.start();
		t2.start();
	}

	class drawmoney implements Runnable {
		@Override
		public void run() {
			while (true) {
				drawmoney.lock();
				while (money < 10005) {
					try {
						changed.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				money--;
				System.out.println("取钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				drawmoney.unlock();
			}
		}
	}

	class savemoney implements Runnable {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				drawmoney.lock();
				money++;
				System.out.println("存钱:" + money);
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				changed.signalAll();
				drawmoney.unlock();
				
			}

		}

	}

}

需要注意的是，调用signalall()这个方法时，应该在获得锁对象之后 。还有一个sign()方法 ，这个方法是从等待集中随机选择一个线程来解除阻塞。而且它并不会立即激活这个线程，而是等待线程通过竞争实现对对象的访问。

上面这种加锁的方法显得有些笨重 ，其实java中也已经提供了更轻便的方法 。synchronized关键字来解决这个问题。不过如果我们知道了上述方法的话，那么对于synchronized的理解会更加容易。
对于刚才那种形式我们就可以写成如下程序 
package test;

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

public class Demo {
	public int money = 10000;
	Lock drawmoney = new ReentrantLock();

	public static void main(String[] Args) {
		new Demo().test();
	}

	private void test() {
		// TODO Auto-generated method stub
		Thread t1 = new Thread(new drawmoney());
		Thread t2 = new Thread(new savemoney());
		t1.start();
		t2.start();
	}

	class drawmoney implements Runnable {
		@Override
		public void run() {
			while (true) {
				synchronized (drawmoney) {
					money--;
					System.out.println("取钱:" + money);
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}

			}
		}
	}

	class savemoney implements Runnable {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
				synchronized (drawmoney) {
					money++;
					System.out.println("存钱:" + money);
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}

				}

			}

		}

	}

}
同时也允许用在方法上。
比如public synchronized void drawmoney()这样之后只允许一个线程来调用这个方法了。

读/写锁

声明方法 ： 
ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
	Lock readmoney = lock2.readLock();
	Lock writemoney = lock2.writeLock();

用法和上面一样，需要注意的是。
读锁可以被多个读操作共用。但会排斥所有写操作。
写锁则和普通锁一样，排斥所有其它操作。



Winney_x
关注
专栏目录
java学习笔记3
zx616122的博客
11-26 5098
面向对象编程 1.中国人，北京人和美国人继承 public class People { protected double weight,height; public void speakHello() { System.out.println("yayaya");} public void averageHeight() { height =173; System.out.println("average height:"+height);} public void averageWeight() {
关于public class 类名{ public static void main(String[] args)}的一些说明
Xue_fabulous的博客
12-28 1万+
1、在java中任何有效的代码必须写到“类体”当中，最外层必须是一个类的定义。 2、public表示公开的，class表示定义一个类，Test是一个类名。类名后面必须是 一对大括号，这一对大括号被称为“类体” 3、大括号必须是成对的。并且建议都要成对编写，这样才不会丢掉。 {} [] () 4、什么时候代码缩进？ 我包着你，你就比我低一级。你就需要缩进。 没有合理的缩进，代码可读性很差。 或者也可以这样所，大括号里的都需要缩进。 缩进就是可读性问题，不缩进也不影响程序的编译和执行。 ...
多线程学习——JAVA三种线程的创建方式
swy66的博客
09-24 352
​ Java中有三种线程创建方式，分别为继承Thread类并重写run的方法，实现Runnable接口的run方法，使用FutureTask方式。 继承Thread类方式的实现。 public class Thread1 extends Thread { @Override public void run() { for(int i=1;i<=10;i++) { System.out.println("多线程执行中..."+i); } } public static v
public static void main(String args[])什么意思？
weixin_33675507的博客
03-09 934
　　public static void main(String[] args) 　　这绝对不是凭空想出来的，也不是没有道理的死规定，而是java程序执行的需要。 　　jvm在试图运行一个类之前，先检查该类是否包含一个特殊方法。这个方法必须是公有的，以便在任何位置都能访问得到。这个方法必须是static的，因为这个方法不能依赖任何该类的实例即可运行，而非static的方法，在运行之前要先创建该...
Java线程与锁知识点总结
qq_24095055的博客
03-14 2805
文章目录Java线程与锁知识点总结进程与线程线程的状态实现线程的几种方式进程和线程的区别Java进程和线程的关系Thread中的start和run方法的区别Thread和Runnable的关系如何实现处理线程的返回值volatile和synchronized的区别sychronized和Locksynchronized和ReentrantLock的区别sleep和wait的区别notify和not...
Java线程锁
最新发布
qq_44715376的博客
06-28 3719
1. synchronized关键字：使用synchronized关键字可以对代码块或方法进行加锁，确保同一时间只有一个线程可以执行被锁定的代码块或方法。 2. ReentrantLock类：ReentrantLock是Java提供的一个可重入锁，它提供了更灵活的锁定机制，可以实现更复杂的同步需求。 3. ReadWriteLock接口：ReadWriteLock接口提供了读写锁的机制，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。 4. Condition接口：Condition接口是
Java中常用的锁总结与理解
热门推荐
张彦峰的博客
05-12 166万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
java 线程锁Lock
幻神舞的专栏
04-15 2245
文章目录说明分享资料synchronized与Lock对比LockLock 接口方法实现类 ReentrantLockReadWriteLockReadWriteLock 接口方法实现类 ReentrantReadWriteLock总结 说明 本博客每周五更新一次。 最近一次开发中使用多线程，过去常用synchronized，基于jvm实现，代码简答，可控性弱，高并发场景效率相对较低，以后尽量多用Lock实现。 Lock实现开始于java 1.5，java.util.concurrent.locks包下L
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4705
Java多线程(四)线程锁
浅析Java 多线程中的锁
沛哥儿的专栏
05-27 2613
补充一点，在使用锁时，我们也应该注意锁的粒度和锁定顺序。锁的粒度越小，锁定的时间就越短，竞争的线程就越少，从而提高并发效率。同时，锁的锁定顺序也会影响并发效率。当多个线程都需要获取多个锁时，如果锁定顺序不同，就可能出现死锁问题。因此，我们需要遵循一定的锁定顺序，尽可能减少死锁的出现。Java 中的锁机制是保证并发访问安全的重要工具。本文详细介绍了 Java 中的锁类型、锁的实现方法、锁的应用场景，以及锁的缺陷和解决方法。在使用锁时，我们需要根据实际的业务场景和运行环境，选择恰当的锁类型和实现方式。
java 线程公平锁与非公平锁详解及实例代码
08-31
Java线程公平锁与非公平锁是并发编程中重要的概念，尤其在使用ReentrantLock时。ReentrantLock是Java并发包（java.util.concurrent）中的一个可重入互斥锁，它提供了比内置的synchronized关键字更为灵活的锁操作。 ...
java线程进程锁资源
02-12
Java线程和进程是计算机程序执行的两种基本方式，它们在多任务环境下尤为关键。Java作为一门多线程编程语言，提供了丰富的工具和机制来管理线程和进程，以实现高效的并发执行。 **进程与线程的区别** 1. **进程**：...
Java多线程锁机制相关原理实例解析
08-18
Java多线程锁机制相关原理实例解析 Java多线程锁机制是指在Java编程语言中，用于解决多线程并发访问共享资源的机制。该机制主要通过锁机制来实现线程同步，确保多线程之间的安全访问共享资源。 锁机制是Java多线程...
解析Java线程同步锁的选择方法
09-05
本文将深入探讨Java线程同步锁的选择方法及其适用场景。 1. **synchronized关键字**： synchronized是Java内置的同步原语，它提供了两种使用方式：方法同步和代码块同步。在上述示例中，`method`方法通过`...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程...总之，Java中的线程同步是通过锁机制实现的，目的是保护共享资源免受并发访问的影响，保证数据的一致性和正确性。开发者应该根据具体需求选择合适的同步策略，以提高程序的并发性能和稳定性。
利用java/android 模拟网页表单提交。可用于爬虫和wif登录器制作
TO TOP CODER
11-03 3896
学校的wifi登录页c
jersey rest webservice实现上传下载
TO TOP CODER
08-16 3394
package com.teamhow.daoimpl; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import j
Java 并发编程之任务取消（六）
TO TOP CODER
09-01 3067
关闭ExecutorService ExecutorService提供了两种关闭方法，使用Shutdown正常关闭，以及使用ShutdownNow强行关闭。在进行强行关闭时，shutdownNow首先关闭当前正在执行的任务。然后返回所有尚未启动的任务清单 。 返回未启动任务清单这句没明白返回的方式，于是去查看了一下源码 /** * Attempts to stop all
Java 并发编程之线程池的使用 （二）
TO TOP CODER
09-06 2649
设置线程池的大小 配置ThreadPoolExecutor 管理队列任务 饱和策略
Java线程锁与条件对象深度解析
本文将深入讲解Java中的线程同步技术，特别是线程锁和条件对象的概念以及其在并发编程中的应用。在多线程环境中，避免数据竞争和并发问题至关重要。Java提供了多种同步机制，其中synchronized关键字是最基础的，它会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值