「java锁超时」java超时控制
今天给各位分享java锁超时的知识，其中也会对java超时控制进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java.sql.SQLException: Lock wait timeout exceeded; try restarting transaction
- 2、java调第三方接口超时会有影响吗
- 3、java 方法 执行超时处理
- 4、北大青鸟java培训：在Java程序中处理数据库超时与死锁？
- 5、java怎么设置获取读写锁超时时间
- 6、java 链接redis 怎么加锁
java.sql.SQLException: Lock wait timeout exceeded; try restarting transaction
事务控制有问题。还有
"update 表2,表3 set ... where ...");
你确认单独可以执行成功?
java调第三方接口超时会有影响吗
java调第三方接口超时会有影响的。根据查询相关公开信息显示，java调第三方接口超时会会导致这个事务的连接一直阻塞，产生交叉死锁。Java是一门面向对象编程语言，1990年代初由詹姆斯·高斯林等人开发出Java语言的雏形，最初被命名为Oak，后随着互联网的发展，经过对Oak的改造，1995年5月Java正式发布。
java 方法 执行超时处理
java 1.5以上的Future类可以执行超时处理。
jdk1.5自带的并发库中Future类中重要方法包括get()和cancel()，get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。
代码如下：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.sun.corba.se.impl.orbutil.closure.Future;
import com.sun.corba.se.impl.orbutil.threadpool.TimeoutException;
public class ThreadTest {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
final ExecutorService exec = Executors.newFixedThreadPool(1);
CallableString call = new CallableString() {
public String call() throws Exception {
//开始执行耗时操作
Thread.sleep(1000 * 5);
return "线程执行完成.";
}
};
try {
FutureString future = exec.submit(call);
String obj = future.get(1000 * 1, TimeUnit.MILLISECONDS); //任务处理超时时间设为 1 秒
System.out.println("任务成功返回:" + obj);
} catch (TimeoutException ex) {
System.out.println("处理超时啦....");
ex.printStackTrace();
} catch (Exception e) {
System.out.println("处理失败.");
e.printStackTrace();
}
// 关闭线程池
exec.shutdown();
}
}
北大青鸟java培训：在Java程序中处理数据库超时与死锁？
每个使用关系型数据库的程序都可能遇到数据死锁或不可用的情况，而这些情况需要在代码中编程来解决;本文主要介绍与数据库事务死锁等情况相关的重试逻辑概念，此外，还会探讨如何避免死锁等问题，文章以DB2(版本9)与为例进行讲解。
什么是数据库锁定与死锁锁定(Locking)发生在当一个事务获得对某一资源的“锁”时，这时，其他的事务就不能更改这个资源了，这种机制的存在是为了保证数据一致性;在设计与数据库交互的程序时，必须处理锁与资源不可用的情况。
锁定是个比较复杂的概念，仔细说起来可能又需要一大篇，所以在本文中，只把锁定看作是一个临时事件，这意味着如果一个资源被锁定，它总会在以后某个时间被释放。
而死锁发生在当多个进程访问同一数据库时，其中每个进程拥有的锁都是其他进程所需的，由此造成每个进程都无法继续下去。
如何避免锁我们可利用事务型数据库中的隔离级别机制来避免锁的创建，正确地使用隔离级别可使程序处理更多的并发事件(如允许多个用户访问数据)，还能预防像丢失修改(LostUpdate)、读“脏”数据(DirtyRead)、不可重复读(NonrepeatableRead)及“虚”(Phantom)等问题。
隔离级别问题现象丢失修改读“脏”数据不可重复读“虚”可重复读取NoNoNoNo读取稳定性NoNoNoYes光标稳定性NoNoYesYes未提交的读NoYesYesYes表1：DB2的隔离级别与其对应的问题现象在只读模式中，就可以防止锁定发生，而不用那些未提交只读隔离级别的含糊语句。
山西电脑培训发现一条SQL语句当使用了下列命令之一时，就应该考虑只读模式了
java怎么设置获取读写锁超时时间
1 package bing.test;
2
3 import java.util.concurrent.locks.Lock;
4 import java.util.concurrent.locks.ReadWriteLock;
5 import java.util.concurrent.locks.ReentrantReadWriteLock;
6
7 public class UpgradeLock{
8 private UpgradeLock(){ }
9 private final static ReadWriteLock rwlock =new ReentrantReadWriteLock();
10 private final static Lock read=rwlock.readLock();
11 private final static Lock write=rwlock.writeLock();
12
13
14 public static void main(String[] args){
15 log(getReadLock());
16 log(getWriteLock());
17 }
18
19
20 public static boolean getReadLock()
21 {
22 try{
23 int time = 0;
24 // 设置超时时间为5秒，获取Lock,
25 //如果返回false(即获取失败)则等待直到超时，然后返回获取lock的状态
26 while(!read.tryLock() ++time 5){
27 Thread.sleep(1000);
28 log(time);
29 }
30 return read.tryLock();
31 }catch(Exception e)
32 {
33 e.printStackTrace();
34 return false;
35 }
36 }
37 public static boolean getWriteLock()
38 {
39 try{
40 int time = 0;
41 // 设置超时时间为5秒，获取Lock,
42 //如果返回false(即获取失败)则等待直到超时，然后返回获取lock的状态
43 while(!write.tryLock() ++time 5){
44 Thread.sleep(1000);
45 log(time);
46 }
47 return read.tryLock();
48 }catch(Exception e)
49 {
50 e.printStackTrace();
51 return false;
52 }
53 }
54 public static void log(Object m){
55 System.out.println(m);
56 }
57 }
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锁超时和java超时控制的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。