「java方法加锁」java中锁的方法有哪些
本篇文章给大家谈谈java方法加锁，以及java中锁的方法有哪些对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
关于JAVA里的加锁synchronized
1.凡使用synchronized标记的方法，比如 public synchronized void func1() { .... }，则同时只有一个线程能够运行这个方法。比如，线程1正在运行func1，则其他线程需要运行func1的话，会卡住，等线程1运行func1结束后，其他线程中，才会有一个幸运儿成功争取到运行func1的资格，然后这个幸运儿线程开始运行func1。没有争取到运行资格的其他线程，会继续等待。
2.你的例子中，被锁定的是 方法 m1，而不是属性b。所以，m1的synchronized加锁操作，与b没有半点毛钱关系。
3.要实现你的锁b想法，其实很简单。去买一件贞操宝甲来就行了。开玩笑，哈哈。要锁b，把main方法里的tt.m2()修改为tt.m1()。
4.以后别用“b”作为变量，总觉得怪怪了。也许你现在还没长大，很单纯。但大人的世界里，“b”是一种不文雅但又对人类的未来有重要作用的东西。建议用cb来代替b。
java对链表加锁并锁住其中的所有元素，
办法倒是有
自己写一个类, 包含一个list属性, 写几个add,get delete等方法,这些方法就是去操作list里面的元素.同时这些方法是加锁,线程安全的
当然了,链表容器本来就有线程安全的,vector等,可以直接用
java 链接redis 怎么加锁
我介绍一下Redis分布式锁吧：
一、定义redis实现分布式锁的接口
[java] view plain copy print?
package com.iol.common.util.concurrent.locks;
import java.io.Serializable;
/**
* Description: 定义redis实现分布式锁的算法br /
* This program is protected by copyright IOL_SMALL_TAIL.br /
* Program Name: IOL_SMALL_TAILbr /
* Date: 2015年11月8日
*
* @author 王鑫
* @version 1.0
*/
public interface IRedisLockArithmetic extends Serializable {
/**
* 加锁算法br /
* @param key
* @return
*/
public boolean lock(String key);
/**
* 解锁算法br /
* @param key
* @return
*/
public boolean unLock(String key);
}
二、redis分布式锁基础算法实现
[java] view plain copy print?
package com.iol.common.util.concurrent.locks.arithmetic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.iol.common.util.concurrent.locks.IRedisComponent;
import com.iol.common.util.concurrent.locks.IRedisLockArithmetic;
/**
* Description: redis分布式锁基础算法实现br /
* This program is protected by copyright IOL_SMALL_TAIL.br /
* Program Name: IOL_SMALL_TAILbr /
* Date: 2015年11月9日
*
* @author 王鑫
* @version 1.0
*/
public class RedisLockBaseArithmetic implements IRedisLockArithmetic {
/**
*serialVersionUID
*/
private static final long serialVersionUID = -8333946071502606883L;
private Logger logger = LoggerFactory.getLogger(RedisLockBaseArithmetic.class);
/**
* redis操作方法
*/
private IRedisComponent redisComp;
/**
* 超时时间，以毫秒为单位br /
* 默认为5分钟
*/
private long overtime = 5 * 60 * 1000L;
/**
* 休眠时长，以毫秒为单位br /
* 默认为100毫秒
*/
private long sleeptime = 100L;
/**
* 当前时间
*/
private long currentLockTime;
/**
* @param redisComp the redisComp to set
*/
public void setRedisComp(IRedisComponent redisComp) {
this.redisComp = redisComp;
}
/**
* @param overtime the overtime to set
*/
public void setOvertime(long overtime) {
this.overtime = overtime;
}
/**
* @param sleeptime the sleeptime to set
*/
public void setSleeptime(long sleeptime) {
this.sleeptime = sleeptime;
}
/* (non-Javadoc)
* @see com.iol.common.util.concurrent.locks.IRedisLockArithmetic#lock(java.lang.String, java.lang.Long)
*/
@Override
public boolean lock(String key) {
while(true) {
// 当前加锁时间
currentLockTime = System.currentTimeMillis();
if(redisComp.setIfAbsent(key, currentLockTime)) {
// 获取锁成功
logger.debug("直接获取锁{key: {}, currentLockTime: {}}", key, currentLockTime);
return true;
} else {
//其他线程占用了锁
logger.debug("检测到锁被占用{key: {}, currentLockTime: {}}", key, currentLockTime);
Long otherLockTime = redisComp.get(key);
if(otherLockTime == null) {
// 其他系统释放了锁
// 立刻重新尝试加锁
logger.debug("检测到锁被释放{key: {}, currentLockTime: {}}", key, currentLockTime);
continue;
} else {
if(currentLockTime - otherLockTime = overtime) {
//锁超时
//尝试更新锁
logger.debug("检测到锁超时{key: {}, currentLockTime: {}, otherLockTime: {}}", key, currentLockTime, otherLockTime);
Long otherLockTime2 = redisComp.getAndSet(key, currentLockTime);
if(otherLockTime2 == null || otherLockTime.equals(otherLockTime2)) {
logger.debug("获取到超时锁{key: {}, currentLockTime: {}, otherLockTime: {}, otherLockTime2: {}}", key, currentLockTime, otherLockTime, otherLockTime2);
return true;
} else {
sleep();
//重新尝试加锁
logger.debug("重新尝试加锁{key: {}, currentLockTime: {}}", key, currentLockTime);
continue;
}
} else {
//锁未超时
sleep();
//重新尝试加锁
logger.debug("重新尝试加锁{key: {}, currentLockTime: {}}", key, currentLockTime);
continue;
}
}
}
}
}
/* (non-Javadoc)
* @see com.iol.common.util.concurrent.locks.IRedisLockArithmetic#unLock(java.lang.String)
*/
@Override
public boolean unLock(String key) {
logger.debug("解锁{key: {}}", key);
redisComp.delete(key);
return true;
}
/**
* 休眠br /
* @param sleeptime
*/
private void sleep() {
try {
Thread.sleep(sleeptime);
} catch (InterruptedException e) {
throw new LockException("线程异常中断", e);
}
}
}
java synchronized对静态方法加锁
2所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
java方法加锁的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中锁的方法有哪些、java方法加锁的信息别忘了在本站进行查找喔。