Java 多线程和死锁

建议我任何需要创建多个线程的实时情况，然后引入死锁情况。这是一种项目！！！u-ppl能否帮助使应用程序更有趣一些实时情况

想想哲学家、金叉和一大碗意大利面

想想哲学家、金叉和一大碗意大利面

你可以使用生产者-消费者算法演示多线程

报表生成器

---

场景是，每个报告的数据都被插入到队列中，由一个服务（生产者）进行进一步处理。报表处理器服务（使用者）从队列中获取报表数据，并一次处理一个报表。报表处理器服务可以有5个不同的实例。它们都使用单个队列中的报告（这是您可能需要在队列上引入锁等的地方）。

您可以使用生产者-消费者算法演示多线程

报表生成器

---

场景是，每个报告的数据都被插入到队列中，由一个服务（生产者）进行进一步处理。报表处理器服务（使用者）从队列中获取报表数据，并一次处理一个报表。报表处理器服务可以有5个不同的实例。它们都使用来自单个队列的报告（这是您可能需要在队列上引入锁等的地方）。

这将导致死锁：

public static void main(String[] args) 
{
  final Object object1 = new Object();
  final Object object2 = new Object();

  Thread thread1 = new Thread(
    new Runnable() 
    {
      public void run() 
      {    
        try 
        {    
          //**** Lock on object1 first ****
          synchronized(object1) 
          {    
            Thread.sleep(1000);

            //**** Lock on object2 second ****
            synchronized(object2) 
            {
              System.out.println("Should never get here.");
            }
          }
        }
        catch (InterruptedException e) 
        {    
          System.out.println("Thread interupted.");
        }
      }
    }
  );

  Thread thread2 = new Thread(
    new Runnable() 
    {
      public void run() 
      {
        try 
        {
          //**** Lock on object2 first ****
          synchronized(object2) 
          {    
            Thread.sleep(1000);

            //**** Lock on object1 second ****
            synchronized(object1) 
            {
              System.out.println("Should never get here.");
            }
          }
        }
        catch (InterruptedException e) 
        {
          System.out.println("Thread interupted.");
        }
      }
    }
  );

  thread1.start();
  thread2.start();
}

---

基本上，有两个线程在同一个对象上竞争锁。线程1在

object1

上获得锁，而线程2在

object2

上获得锁，然后每个线程都试图在另一个对象上获得锁，而您已经处于死锁状态，因为另一个线程已经具有该锁。

这将导致死锁：

public static void main(String[] args) 
{
  final Object object1 = new Object();
  final Object object2 = new Object();

  Thread thread1 = new Thread(
    new Runnable() 
    {
      public void run() 
      {    
        try 
        {    
          //**** Lock on object1 first ****
          synchronized(object1) 
          {    
            Thread.sleep(1000);

            //**** Lock on object2 second ****
            synchronized(object2) 
            {
              System.out.println("Should never get here.");
            }
          }
        }
        catch (InterruptedException e) 
        {    
          System.out.println("Thread interupted.");
        }
      }
    }
  );

  Thread thread2 = new Thread(
    new Runnable() 
    {
      public void run() 
      {
        try 
        {
          //**** Lock on object2 first ****
          synchronized(object2) 
          {    
            Thread.sleep(1000);

            //**** Lock on object1 second ****
            synchronized(object1) 
            {
              System.out.println("Should never get here.");
            }
          }
        }
        catch (InterruptedException e) 
        {
          System.out.println("Thread interupted.");
        }
      }
    }
  );

  thread1.start();
  thread2.start();
}

---

基本上，有两个线程在同一个对象上竞争锁。线程1在

object1

上获得锁，而线程2在

object2

上获得锁，然后每个线程都试图在另一个对象上获得锁，而您已经处于死锁状态，因为另一个线程已经具有该锁。

您还可以使用固定大小的线程池进行死锁：

final ExecutorService exec = Executors.newFixedThreadPool(1);
exec.submit(new Runnable() {
    public void run() {
        Future<?> f = exec.submit(new Runnable() {
            public void run() {
            }
        });
        try { f.get(); } catch (Exception ex) { }
    }
});

final ExecutorService exec=Executors.newFixedThreadPool（1）；
exec.submit（新的Runnable（）{
公开募捐{
Future f=exec.submit（new Runnable（））{
公开募捐{
}
});
尝试{f.get（）；}catch（Exception ex）{}
}
});

您还可以使用固定大小的线程池进行死锁：

final ExecutorService exec = Executors.newFixedThreadPool(1);
exec.submit(new Runnable() {
    public void run() {
        Future<?> f = exec.submit(new Runnable() {
            public void run() {
            }
        });
        try { f.get(); } catch (Exception ex) { }
    }
});

final ExecutorService exec=Executors.newFixedThreadPool（1）；
exec.submit（新的Runnable（）{
公开募捐{
Future f=exec.submit（new Runnable（））{
公开募捐{
}
});
尝试{f.get（）；}catch（Exception ex）{}
}
});

你需要自己想出点子，因为这是你的作业。所谓“实时”，你的意思是当你问这个问题时，作业就要交上来了吗？你需要自己想出点子，因为这是你的作业。所谓“实时”你的意思是当你问这个问题的时候作业就要交了吗？我听说他们在吃饭，但是金叉？！？哲学家们已经在世界上升迁了这是一个实时的例子还是教科书上的例子：）这是很久以前的事了，也许我发明了金叉我听说他们吃饭，但是金叉？！？哲学家们已经在世界上取得了进步这是一个实时示例还是教科书示例：）这是很久以前的事了，也许我发明了金叉睡眠不能保证死锁。睡眠是给每个线程时间来获得他们的第一个锁（分别在

object1

和

object2

上）在尝试获取第二个锁之前（分别在

object2

和

object1

上）。虽然有可能

thread2

在1000毫秒内没有锁定，但可能性不大。最后，

sleep

是一种简单的机制，可以使死锁发生，但它不是死锁本身的原因，原因是相互竞争的锁。非常感谢。如果有一个特定的问题，比如编写一个总是以死锁告终的程序，那么我必须考虑其他的方法，对吗？睡眠并不能保证死锁。睡眠给每个线程时间来获得它们的第一个锁（分别在

object1

和

object2

上）在尝试获取第二个锁之前（分别在

object2

和

object1

上）。虽然有可能

thread2

在1000毫秒内没有锁定，但可能性不大。最后，

sleep

是一种简单的机制，可以使死锁发生，但它不是死锁本身的原因，原因是相互竞争的锁。非常感谢。如果有一个特定的问题，比如写一个程序，它总是会在死锁中结束，那么我必须想一些其他的方法，对吗？