正文
java死锁的实现代码，java 死锁代码
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
JAVA死锁
主线程保持着A对象的锁意思就是主线程正在处理A对象，其他线程不能处理，要等待主线程结束之后其他线程才能处理A对象。
同理副线程正在处理B对象，A不能处理，所以主线程结束不了，一直在等待。
两个线程都运行不下去了就叫做死锁，程序崩溃。
加锁的意思就是某线程正在处理某对象，其他线程不能处理。
手打不容易，明白不明白都给分吧- -、
相关问答
Q1: java线程死锁
// 我不想分析你的问题，但是我发一段我写的死锁代码
package com.demo;
public class DeadLock implements Runnable{
//测试死锁的例子;
//声明两个KEY;用于加锁使用;
private static final String KEY1="KEY1";
private static final String KEY2="KEY2";
private boolean lock;
public DeadLock(boolean lock){
this.lock = lock;
//调用boolean true|false 赋值给lock进行判断key1和key2；
}
public void run(){
if(lock){
synchronized(KEY1){//第一次锁KEY1
try{
Thread.sleep(3000);
}catch(Exception e){
}
System.out.println("给我KEY2我要使用!");
synchronized(KEY2){//第二次锁KEY2
System.out.println("我拿到KEY2运行结束!");
}
}
}else{
synchronized(KEY2){//第一次锁KEY2
try{
Thread.sleep(3000);
}catch(Exception e){
}
System.out.println("Give me KEY1,I will use!");
synchronized(KEY1){//第二次锁KEY1
System.out.println("我拿到KEY1运行结束!");
}
}
}
}
public static void main(String args[]){
new Thread(new DeadLock(true)).start();
new Thread(new DeadLock(false)).start();
}
}
Q2: JAVA线程死锁问题：希望写一个死锁程序，但是发现可以正常运行，求助大神解释
flag 为 true 时，线程1 synchronized(o1) 睡 500ms 就把 o1 的锁释放了，线程2 只需要等 500ms 就可以获得 o1 的锁了。同理，线程2 synchronized(o2) 睡 500ms 就把 o2 的锁释放了，线程1 只需要等 500ms 就可以获得 o2 的锁了。
要造成死锁，需要线程1 在占有 o1 锁的时候再去占有 o2 锁，线程2 在占有 o2 锁的时候再去占有 o2 锁。
线程1：
synchronized(o1) {
synchronized(o2) {
}
}
线程2：
synchronized(o2) {
synchronized(o1) {
}
}
Q3: 哪位大哥可以用JAVA举几个简单的小例子帮我演示一下死锁现象?
以下为一具体的Java实例说明死锁：
public
class
DeadLock
implements
Runnable
{
public
int
flag
=
1;
static
Object
o1
=
new
Object();
static
Object
o2
=
new
Object();
public
void
run()
{
System.out.println("flag="
+
flag);
//
当flag==1锁住o1
if
(flag
==
1)
{
synchronized
(o1)
{
try
{
Thread.sleep(500);
}
catch
(Exception
e)
{
e.printStackTrace();
}
//
只要锁住o2就完成
synchronized
(o2)
{
System.out.println("1");
}
}
}
//
如果flag==0锁住o2
if
(flag
==
0)
{
synchronized
(o2)
{
try
{
Thread.sleep(500);
}
catch
(Exception
e)
{
e.printStackTrace();
}
//
只要锁住o1就完成
synchronized
(o1)
{
System.out.println("0");
}
}
}
}
public
static
void
main(String[]
args)
{
//
实例2个线程类
DeadLock
td1
=
new
DeadLock();
DeadLock
td2
=
new
DeadLock();
td1.flag
=
1;
td2.flag
=
0;
//
开启2个线程
Thread
t1
=
new
Thread(td1);
Thread
t2
=
new
Thread(td2);
t1.start();
t2.start();
}
}
Q4: 如何通过编程发现Java死锁
死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是，确保在某个时刻只有一个线程被允许执行特定的代码块，因此，被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时，线程会给对象加锁，而这个锁导致其它也想访问同一对象的线程被阻塞，直至第一个线程释放它加在对象上的锁。
由于这个原因，在使用“synchronized”关键词时，很容易出现两个线程互相等待对方做出某个动作的情形。代码一是一个导致死锁的简单例子。
//代码一
class Deadlocker {
int field_1;
private Object lock_1 = new int[1];
int field_2;
private Object lock_2 = new int[1];
public void method1(int value) {
“synchronized” (lock_1) {
“synchronized” (lock_2) {
field_1 = 0; field_2 = 0;
}
}
}
public void method2(int value) {
“synchronized” (lock_2) {
“synchronized” (lock_1) {
field_1 = 0; field_2 = 0;
}
}
}
}
参考代码一，考虑下面的过程：
◆ 一个线程（ThreadA）调用method1()。
◆ ThreadA在lock_1上同步，但允许被抢先执行。
◆ 另一个线程（ThreadB）开始执行。
◆ ThreadB调用method2()。
◆ ThreadB获得lock_2，继续执行，企图获得lock_1。但ThreadB不能获得lock_1，因为ThreadA占有lock_1。
◆ 现在，ThreadB阻塞，因为它在等待ThreadA释放lock_1。
◆ 现在轮到ThreadA继续执行。ThreadA试图获得lock_2，但不能成功，因为lock_2已经被ThreadB占有了。
◆ ThreadA和ThreadB都被阻塞，程序死锁。
当然，大多数的死锁不会这么显而易见，需要仔细分析代码才能看出，对于规模较大的多线程程序来说尤其如此。好的线程分析工具，例如JProbe Threadalyzer能够分析死锁并指出产生问题的代码位置。
隐性死锁
隐性死锁由于不规范的编程方式引起，但不一定每次测试运行时都会出现程序死锁的情形。由于这个原因，一些隐性死锁可能要到应用正式发布之后才会被发现，因此它的危害性比普通死锁更大。下面介绍两种导致隐性死锁的情况：加锁次序和占有并等待。
加锁次序
当多个并发的线程分别试图同时占有两个锁时，会出现加锁次序冲突的情形。如果一个线程占有了另一个线程必需的锁，就有可能出现死锁。考虑下面的情形，ThreadA和ThreadB两个线程分别需要同时拥有lock_1、lock_2两个锁，加锁过程可能如下：
◆ ThreadA获得lock_1；
◆ ThreadA被抢占，VM调度程序转到ThreadB；
◆ ThreadB获得lock_2；
◆ ThreadB被抢占，VM调度程序转到ThreadA；
◆ ThreadA试图获得lock_2，但lock_2被ThreadB占有，所以ThreadA阻塞；
◆ 调度程序转到ThreadB；
◆ ThreadB试图获得lock_1，但lock_1被ThreadA占有，所以ThreadB阻塞；
◆ ThreadA和ThreadB死锁。
必须指出的是，在代码丝毫不做变动的情况下，有些时候上述死锁过程不会出现，VM调度程序可能让其中一个线程同时获得lock_1和lock_2两个锁，即线程获取两个锁的过程没有被中断。在这种情形下，常规的死锁检测很难确定错误所在。
占有并等待
如果一个线程获得了一个锁之后还要等待来自另一个线程的通知，可能出现另一种隐性死锁，考虑代码二。
//代码二
public class queue {
static java.lang.Object queueLock_;
Producer producer_;
Consumer consumer_;
public class Producer {
void produce() {
while (!done) {
“synchronized” (queueLock_) {
produceItemAndAddItToQueue();
“synchronized” (consumer_) {
consumer_.notify();
}
}
}
}
public class Consumer {
consume() {
while (!done) {
“synchronized” (queueLock_) {
“synchronized” (consumer_) {
consumer_.wait();
}
removeItemFromQueueAndProcessIt();
}
}
}
}
}
}
在代码二中，Producer向队列加入一项新的内容后通知Consumer，以便它处理新的内容。问题在于，Consumer可能保持加在队列上的锁，阻止Producer访问队列，甚至在Consumer等待Producer的通知时也会继续保持锁。这样，由于Producer不能向队列添加新的内容，而Consumer却在等待Producer加入新内容的通知，结果就导致了死锁。
在等待时占有的锁是一种隐性的死锁，这是因为事情可能按照比较理想的情况发展—Producer线程不需要被Consumer占据的锁。尽管如此，除非有绝对可靠的理由肯定Producer线程永远不需要该锁，否则这种编程方式仍是不安全的。有时“占有并等待”还可能引发一连串的线程等待，例如，线程A占有线程B需要的锁并等待，而线程B又占有线程C需要的锁并等待等。
要改正代码二的错误，只需修改Consumer类，把wait()移出“synchronized”()即可。
Q5: java线程同步，死锁题目求代码
可以建一个类作为锁 然后两个线程
......
synchronized (seed) {
......
seed.notifyAll();
try {
seed.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
以下仅供参考
package com.kidd.test.zhidao;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
/**
* Hello world!
*
*/
public class Main {
public static void main(String[] args) {
ListInteger pais = new ArrayList();
ListInteger list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
pais.addAll(list);
pais.addAll(list);
Seed seed = new Seed();
Person person1 = new Person(0, "玩家A", seed);
Person person2 = new Person(1, "玩家B", seed);
fapai(pais, person1, person2);
Thread thread1 = new Thread(person1);
Thread thread2 = new Thread(person2);
thread1.start();
thread2.start();
}
private static void fapai(ListInteger pais, Person person1, Person person2) {
int i = 1;
int index;
Random random = new Random();
while (pais.size() 0) {
switch (i) {
case 1: {
index = pais.remove(random.nextInt(pais.size()));
person1.addPai(index);
i++;
break;
}
case 2: {
index = pais.remove(random.nextInt(pais.size()));
person2.addPai(index);
i = 1;
break;
}
}
}
Arrays.sort(person1.getPais());
Arrays.sort(person2.getPais());
System.out.println("牌发完了.");
System.out.println(person1.getName() + ":我的牌组是" + Arrays.toString(person1.getPais()));
System.out.println(person2.getName() + ":我的牌组是" + Arrays.toString(person1.getPais()));
}
}
class Person implements Runnable {
private int index;
private int n;
private int[] pais = new int[13];
private String name;
private Seed seed;
public Person(int index, String name, Seed seed) {
this.index = index;
this.name = name;
this.seed = seed;
}
public Seed getSeed() {
return seed;
}
public String getName() {
return name;
}
public int[] getPais() {
return pais;
}
public void setPais(int[] pais) {
this.pais = pais;
}
public int getN() {
return n;
}
public int addPai(int i) {
pais[n] = i;
n++;
return n;
}
@Override
public void run() {
synchronized (seed) {
while (!seed.isEnd() n != 0) {
/**
* 判断是否轮到该玩家出牌,否则唤醒其他线程并且该线程睡眠.
*/
while (seed.getIndex() != this.index) {
seed.notifyAll();
try {
seed.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 线程唤醒后,检查中断标记
*/
if (seed.isEnd()) {
break;
}
/**
* 判断出牌是否成功,成功就轮到下一个玩家.否则重置牌,并轮到下一个玩家.
*/
if (chupai()) {
seed.nextIndex();
} else {
seed.nextIndex();
seed.setPai(0);
}
}
/**
* 设置线程退出的标记
*/
seed.setEnd(true);
if (n == 0) {
System.out.println(name + ":牌出完了,我赢了.");
} else {
System.out.println(name + ":我输了.还剩" + n + "张牌.牌组是:" + Arrays.toString(pais));
}
/**
* 退出前把其他线程唤醒.
*/
seed.notifyAll();
}
}
private boolean chupai() {
int a;
for (int i = 0, k = pais.length; i k; i++) {
a = pais[i];
if (a != 0 a seed.getPai()) {
System.out.println(name + ":大你。我出" + pais[i]);
seed.setPai(a);
pais[i] = 0;
n--;
return true;
}
}
System.out.println(name + "不出牌：(无牌可出).");
return false;
}
}
class Seed {
private boolean end;
private int pai;
private int index;
public boolean isEnd() {
return end;
}
public int getPai() {
return pai;
}
public void setPai(int pai) {
this.pai = pai;
}
public int getIndex() {
return index;
}
public void nextIndex() {
this.index++;
if (this.index == 2) {
this.index = 0;
}
}
public void setEnd(boolean end) {
this.end = end;
}
}
关于java死锁的实现代码和java 死锁代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
