黑马程序员技术交流社区

标题: 多线程问题 [打印本页]
作者: 小白马__^o^    时间: 2014-8-8 15:54
标题: 多线程问题
本帖最后由 小白马__^o^ 于 2014-8-8 16:00 编辑

各位大神啊！ 帮小弟看一下这道程序，执行不下去啊！
程序要求是这样的：
有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....   
D：4 1 2 3 4 1....

这是小弟写的代码，可是就是有问题！还请大神们指导指导！

  1. import java.util.concurrent.ExecutorService;
  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.locks.Condition;        
  4. import java.util.concurrent.locks.*;

  6. public class Test06
  7. {
  8.         public static void main(String args[])
  9.         {
  10.                 ShiXian shi = new ShiXian();
  11.                
  12.                 ExecutorService service = Executors.newFixedThreadPool(4);        //实例化一个线程池，池里面可以放4个线程
  13.                 service.execute(new Thread(new Thread01(shi)));                //将线程1放进去池中进行执行
  14.                 service.execute(new Thread(new Thread02(shi)));
  15.                 service.execute(new Thread(new Thread03(shi)));
  16.                 service.execute(new Thread(new Thread04(shi)));
  17.         }
  18. }
  19. class ShiXian
  20. {
  21.         Lock lock = new ReentrantLock();
  22.         Condition ThreadA = lock.newCondition();         
  23.         Condition ThreadB = lock.newCondition();         
  24.         Condition ThreadC = lock.newCondition();         
  25.         Condition ThreadD = lock.newCondition();        
  26.         int flag = 1;
  27.         //int [] buff = new int[6];

  29.         public void lock01()     //加锁方法1
  30.         {
  31.                 for (int i=1; i <=6;)
  32.                  {
  33.                         lock.lock();
  34.                         try
  35.                         {
  36.                                 while(flag != 1)
  37.                                 {
  38.                                         try
  39.                                         {
  40.                                                 ThreadA.await();
  41.                                         }
  42.                                         catch (Exception e)
  43.                                         {
  44.                                                 e.printStackTrace();
  45.                                         }
  46.                                 }
  47.                                 System.out.print(1 + " ");
  48.                                 //buff[0] = flag;
  49.                                 flag = 2;
  50.                                 ThreadB.signal();
  51.                                  i++ ;
  52.                         }
  53.                         finally
  54.                         {
  55.                                 lock.unlock();
  56.                         }
  57.                 }
  58.         }
  59.         public void lock02()    //加锁方法2
  60.         {
  61.                 for (int i=1; i <=6; i++ )
  62.                  {
  63.                         lock.lock();
  64.                         try
  65.                         {
  66.                                 while(flag != 2)
  67.                                 {
  68.                                         try
  69.                                         {
  70.                                                 ThreadA.await();
  71.                                         }
  72.                                         catch (Exception e)
  73.                                         {
  74.                                                 e.printStackTrace();
  75.                                         }
  76.                                 }
  77.                                 System.out.print(2 + " ");
  78.                                 //System.out.println();
  79.                                 //buff[1] = flag;
  80.                                 flag = 3;
  81.                                 ThreadC.signal();
  82.                                  i++ ;
  83.                         }
  84.                         finally
  85.                         {
  86.                                 lock.unlock();
  87.                         }
  88.                 }
  89.         }
  90.         public void lock03()    //加锁方法3
  91.         {
  92.                 for (int i=1; i <=6; i++ )
  93.                  {
  94.                         lock.lock();
  95.                         try
  96.                         {
  97.                                 while(flag != 3)
  98.                                 {
  99.                                         try
  100.                                         {
  101.                                                 ThreadA.await();
  102.                                         }
  103.                                         catch (Exception e)
  104.                                         {
  105.                                                 e.printStackTrace();
  106.                                         }
  107.                                 }
  108.                                 System.out.print(3 + " ");
  109.                                 //buff[2] = flag;
  110.                                 flag = 4;
  111.                                 ThreadD.signal();
  112.                                  i++ ;
  113.                         }
  114.                         finally
  115.                         {
  116.                                 lock.unlock();
  117.                         }
  118.                 }
  119.         }
  120.         public void lock04()    //加锁方法4
  121.         {
  122.                 for (int i=1; i <=6; i++ )
  123.                  {
  124.                         lock.lock();
  125.                         try
  126.                         {
  127.                                 while(flag != 4)
  128.                                 {
  129.                                         try
  130.                                         {
  131.                                                 ThreadA.await();
  132.                                         }
  133.                                         catch (Exception e)
  134.                                         {
  135.                                                 e.printStackTrace();
  136.                                         }
  137.                                 }
  138.                                 System.out.print(4 + " ");
  139.                                 //buff[3] = flag;

  141.                                 flag = 1;
  142.                                 ThreadA.signal();
  143.                                  i++ ;
  144.                         }
  145.                         finally
  146.                         {
  147.                                 lock.unlock();
  148.                         }
  149.                 }
  150.         }
  151. }

  153. class Thread01 implements Runnable   //线程1
  154. {
  155.         ShiXian shi = null;

  157.         public Thread01(ShiXian shi)
  158.         {
  159.                 this.shi = shi;
  160.         }
  161.         public void run()
  162.         {
  163.                 shi.lock01();
  164.         }
  165. }

  167. class Thread02 implements Runnable   //线程2
  168. {
  169.         ShiXian shi = null;

  171.         public Thread02(ShiXian shi)
  172.         {
  173.                 this.shi = shi;
  174.         }
  175.         public void run()
  176.         {
  177.                 shi.lock02();
  178.         }
  179. }

  181. class Thread03 implements Runnable   //线程3
  182. {
  183.         ShiXian shi = null;

  185.         public Thread03(ShiXian shi)
  186.         {
  187.                 this.shi = shi;
  188.         }
  189.         public void run()
  190.         {
  191.                 shi.lock03();
  192.         }
  193. }

  195. class Thread04 implements Runnable  //线程4
  196. {
  197.         ShiXian shi = null;

  199.         public Thread04(ShiXian shi)
  200.         {
  201.                 this.shi = shi;
  202.         }
  203.         public void run()
  204.         {
  205.                 shi.lock04();
  206.         }
  207. }

复制代码




然后程序停在哪儿就不往下执行了，这是怎么回事儿啊！





作者: 天黑偷牛    时间: 2014-8-8 16:47
额(⊙o⊙)…，我水平有点低，还没看懂
作者: 天黑偷牛    时间: 2014-8-8 16:48
应该是死锁吧，我还没找到在哪
作者: 小白马__^o^    时间: 2014-8-8 18:56
天黑偷牛 发表于 2014-8-8 16:48
应该是死锁吧，我还没找到在哪

恩恩！ 我想应该也是死锁吧！ 但是就不知道怎么解决！ 哎！郁闷啊！还请大神指教！{:2_32:}
作者: 回头浪子心    时间: 2014-8-8 20:20
呵呵，，， 我不会告诉你，我也不懂~~~
作者: 乐此不疲    时间: 2014-8-8 20:59
你的await跟sigal用的挺混乱的，应该交替A-B B-C C-D D-A这样保证循环，还有你的for循环中i++有时出现在for之后，有的出现在语句体中。。。  帮你改了下
  1. import java.util.concurrent.ExecutorService;
  2. import java.util.concurrent.Executors;
  3. import java.util.concurrent.locks.Condition;        
  4. import java.util.concurrent.locks.*;

  6. public class Test06
  7. {
  8.         public static void main(String args[])
  9.         {
  10.                 ShiXian shi = new ShiXian();
  11.                
  12.                 ExecutorService service = Executors.newFixedThreadPool(4);        //实例化一个线程池，池里面可以放4个线程
  13.                 service.execute(new Thread(new Thread01(shi)));                //将线程1放进去池中进行执行
  14.                 service.execute(new Thread(new Thread02(shi)));
  15.                 service.execute(new Thread(new Thread03(shi)));
  16.                 service.execute(new Thread(new Thread04(shi)));
  17.         }
  18. }
  19. class ShiXian
  20. {
  21.         Lock lock = new ReentrantLock();
  22.         Condition ThreadA = lock.newCondition();         
  23.         Condition ThreadB = lock.newCondition();         
  24.         Condition ThreadC = lock.newCondition();         
  25.         Condition ThreadD = lock.newCondition();        
  26.         int flag = 1;
  27.         //int [] buff = new int[6];

  29.         public void lock01()     //加锁方法1
  30.         {
  31.                 for (int i=1; i <=6;)
  32.                  {
  33.                         lock.lock();
  34.                         try
  35.                         {
  36.                                 while(flag != 1)
  37.                                 {
  38.                                         try
  39.                                         {
  40.                                                 ThreadA.await();
  41.                                         }
  42.                                         catch (Exception e)
  43.                                         {
  44.                                                 e.printStackTrace();
  45.                                         }
  46.                                 }
  47.                                 System.out.print(1 + " ");
  48.                                 //buff[0] = flag;
  49.                                 flag = 2;
  50.                                 ThreadB.signal();
  51.                                  i++ ;
  52.                         }
  53.                         finally
  54.                         {
  55.                                 lock.unlock();
  56.                         }
  57.                 }
  58.         }
  59.         public void lock02()    //加锁方法2
  60.         {
  61.                 for (int i=1; i <=6; i++ )
  62.                  {
  63.                         lock.lock();
  64.                         try
  65.                         {
  66.                                 while(flag != 2)
  67.                                 {
  68.                                         try
  69.                                         {
  70.                                                 ThreadA.await();
  71.                                         }
  72.                                         catch (Exception e)
  73.                                         {
  74.                                                 e.printStackTrace();
  75.                                         }
  76.                                 }
  77.                                 System.out.print(2 + " ");
  78.                                 //System.out.println();
  79.                                 //buff[1] = flag;
  80.                                 flag = 3;
  81.                                 ThreadC.signal();
  82.                                  i++ ;
  83.                         }
  84.                         finally
  85.                         {
  86.                                 lock.unlock();
  87.                         }
  88.                 }
  89.         }
  90.         public void lock03()    //加锁方法3
  91.         {
  92.                 for (int i=1; i <=6; i++ )
  93.                  {
  94.                         lock.lock();
  95.                         try
  96.                         {
  97.                                 while(flag != 3)
  98.                                 {
  99.                                         try
  100.                                         {
  101.                                                 ThreadA.await();
  102.                                         }
  103.                                         catch (Exception e)
  104.                                         {
  105.                                                 e.printStackTrace();
  106.                                         }
  107.                                 }
  108.                                 System.out.print(3 + " ");
  109.                                 //buff[2] = flag;
  110.                                 flag = 4;
  111.                                 ThreadD.signal();
  112.                                  i++ ;
  113.                         }
  114.                         finally
  115.                         {
  116.                                 lock.unlock();
  117.                         }
  118.                 }
  119.         }
  120.         public void lock04()    //加锁方法4
  121.         {
  122.                 for (int i=1; i <=6; i++ )
  123.                  {
  124.                         lock.lock();
  125.                         try
  126.                         {
  127.                                 while(flag != 4)
  128.                                 {
  129.                                         try
  130.                                         {
  131.                                                 ThreadA.await();
  132.                                         }
  133.                                         catch (Exception e)
  134.                                         {
  135.                                                 e.printStackTrace();
  136.                                         }
  137.                                 }
  138.                                 System.out.print(4 + " ");
  139.                                 //buff[3] = flag;

  141.                                 flag = 1;
  142.                                 ThreadA.signal();
  143.                                  i++ ;
  144.                         }
  145.                         finally
  146.                         {
  147.                                 lock.unlock();
  148.                         }
  149.                 }
  150.         }
  151. }

  153. class Thread01 implements Runnable   //线程1
  154. {
  155.         ShiXian shi = null;

  157.         public Thread01(ShiXian shi)
  158.         {
  159.                 this.shi = shi;
  160.         }
  161.         public void run()
  162.         {
  163.                 shi.lock01();
  164.         }
  165. }

  167. class Thread02 implements Runnable   //线程2
  168. {
  169.         ShiXian shi = null;

  171.         public Thread02(ShiXian shi)
  172.         {
  173.                 this.shi = shi;
  174.         }
  175.         public void run()
  176.         {
  177.                 shi.lock02();
  178.         }
  179. }

  181. class Thread03 implements Runnable   //线程3
  182. {
  183.         ShiXian shi = null;

  185.         public Thread03(ShiXian shi)
  186.         {
  187.                 this.shi = shi;
  188.         }
  189.         public void run()
  190.         {
  191.                 shi.lock03();
  192.         }
  193. }

  195. class Thread04 implements Runnable  //线程4
  196. {
  197.         ShiXian shi = null;

  199.         public Thread04(ShiXian shi)
  200.         {
  201.                 this.shi = shi;
  202.         }
  203.         public void run()
  204.         {
  205.                 shi.lock04();
  206.         }
  207. }
复制代码
作者: fantacyleo    时间: 2014-8-8 21:03
那么多锁，唯恐不死锁的节奏啊。。。其实用CyclicBarrier就很容易解决了。
  1. import java.util.concurrent.*;
  2. import java.io.*;

  4. /** 有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推....现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
  5. * A：1 2 3 4 1 2....
  6. * B：2 3 4 1 2 3....
  7. * C：3 4 1 2 3 4....   
  8. * D：4 1 2 3 4 1....
  9. *
  10. * 思路：
  11. *         四个线程分别写四个文件，写好之后，在同一个CyclicBarrier上等待，执行barrier action，互换各自要写入的文件，再开始下一轮写入
  12. */

  14. public class MultipleThreadWriter {
  15.        
  16.         public static void main(String[] args) throws Exception {

  18.                 FileWriter file1 = new FileWriter("c:\\1.txt");
  19.                 FileWriter file2 = new FileWriter("c:\\2.txt");
  20.                 FileWriter file3 = new FileWriter("c:\\3.txt");
  21.                 FileWriter file4 = new FileWriter("c:\\4.txt");

  23.                 final ThreadWriter tw1 = new ThreadWriter(file1, '1');
  24.                 final ThreadWriter tw2 = new ThreadWriter(file2, '2');
  25.                 final ThreadWriter tw3 = new ThreadWriter(file3, '3');
  26.                 final ThreadWriter tw4 = new ThreadWriter(file4, '4');

  28.                 CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
  29.                         public void run() {
  30.                                 FileWriter temp1 = tw1.getFileWriter();
  31.                                 FileWriter temp2 = tw2.getFileWriter();
  32.                                 FileWriter temp3 = tw3.getFileWriter();
  33.                                 FileWriter temp4 = tw4.getFileWriter();

  35.                                 // 互换四个线程的写入文件
  36.                                 tw1.setFileWriter(temp4);
  37.                                 tw2.setFileWriter(temp1);
  38.                                 tw3.setFileWriter(temp2);
  39.                                 tw4.setFileWriter(temp3);
  40.                         }
  41.                 });
  42.                
  43.                 tw1.setBarrier(barrier);
  44.                 tw2.setBarrier(barrier);
  45.                 tw3.setBarrier(barrier);
  46.                 tw4.setBarrier(barrier);
  47.                
  48.                 ExecutorService exec = Executors.newCachedThreadPool();
  49.                 exec.execute(tw1);
  50.                 exec.execute(tw2);
  51.                 exec.execute(tw3);
  52.                 exec.execute(tw4);

  54.                 TimeUnit.MILLISECONDS.sleep(10);
  55.                 exec.shutdownNow();
  56.         }


  59. }


  62. class ThreadWriter implements Runnable {
  63.         private FileWriter fw;
  64.         private char c;
  65.         private CyclicBarrier barrier;
  66.         public ThreadWriter(FileWriter fw, char c) {
  67.                 this.fw = fw;
  68.                 this.c = c;
  69.         }

  71.         public void setFileWriter(FileWriter fw) {
  72.                 this.fw = fw;
  73.         }

  75.         public FileWriter getFileWriter() {
  76.                 return fw;
  77.         }
  78.        
  79.         public void setBarrier(CyclicBarrier barrier) {
  80.                 this.barrier = barrier;
  81.         }

  83.         public void run() {
  84.                 try {
  85.                         while (!Thread.interrupted()) {
  86.                                 fw.write(c + " ");
  87.                                 barrier.await();
  88.                         }
  89.                 } catch(InterruptedException e) {
  90.                        
  91.                 } catch(BrokenBarrierException e) {
  92.                        
  93.                 } catch(IOException e) {
  94.                        
  95.                 } finally {
  96.                         try {
  97.                                 fw.close();
  98.                         } catch (IOException e) {
  99.                                
  100.                         }
  101.                 }
  102.                
  103.         }
  104. }
复制代码
作者: lcycr    时间: 2014-8-8 21:05
二楼的代码太给力了
作者: 小白马__^o^    时间: 2014-8-8 22:02
fantacyleo 发表于 2014-8-8 21:03
那么多锁，唯恐不死锁的节奏啊。。。其实用CyclicBarrier就很容易解决了。

fantacyleo  大神啊！ 你真的太给力了！ 厉害！小弟受教了！{:2_32:}
作者: 刘小记.    时间: 2014-8-8 22:13
学习学习



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2