黑马程序员技术交流社区

标题: 多线程：循环打印10次ABC [打印本页]

作者: 胡建伟 时间: 2013-11-10 20:05
标题: 多线程：循环打印10次ABC
本帖最后由胡建伟于 2013-11-13 00:15 编辑

今天复习多线程，做练习时候在网上找到一个三线程问题：有三个线程ID分别是A、B、C,请有多线编程实现,在屏幕上循环打印10次ABCABC
看似很简单，可是做起来费了很大劲，最后逛论坛找到一种使用join()方法实现，但是还是没有完全理解，希望高手们能帮忙详细解释下，除了此方法是否还有其他方法可以实现？
package itheimabiji;
public class duoxiancheng {
public static void main(String[] args) {
Thread_E tc = new Thread_E();
      Thread_E tb = new Thread_E();
      Thread_A ta = new Thread_A();

      ta.setThread(tb);
      tb.setThread(tc);
      tc.setThread(ta);

      ta.setName("A");
      tb.setName("B");
      tc.setName("C");

      ta.start();
      tb.start();
      tc.start();

   }
}
class Thread_A extends Thread {
   Thread t;
   public void setThread(Thread t) {
      this.t = t;
   }
   public void run() {
      int i = 0;
      while(i++ < 10) {
         System.out.print(Thread.currentThread().getName());
         t.interrupt();
         try {
               this.join();
         } catch (InterruptedException e) {

         }
      }
   }
}
class Thread_E extends Thread {
   Thread t;
   public void setThread(Thread t) {
      this.t = t;
   }
   public void run() {
      int i = 0;
      while(i++ < 10) {
         try {
               this.join();

         } catch (InterruptedException e) {

         }
         System.out.print(Thread.currentThread().getName());
         t.interrupt();
      }
   }
}

作者: 王雨神 时间: 2013-11-11 17:02
看不懂题目呢？？？

作者: 赵许星 时间: 2013-11-12 10:13
t1,t2是两个独立的线程，还有一个线程就是我们的主线程。
t1.start();
t2.start();//开始执行线程
t1.join();//当前线程等待t1执行完成，注意这是指main线程会等待t1执行完成以后才执行后面的代码。这里与t2毫无关系，所以t2当然不会等待，等待的只是main线程。
class ThreadTesterA implements Runnable {

private int counter;

@Override
public void run() {
while (counter <= 10) {
System.out.print("Counter = " + counter + " ");
counter++;
}
System.out.println();
}
}

class ThreadTesterB implements Runnable {

private int i;

@Override
public void run() {
while (i <= 10) {
System.out.print("i = " + i + " ");
i++;
}
System.out.println();
}
}

public class ThreadTester {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new ThreadTesterA());
Thread t2 = new Thread(new ThreadTesterB());
t1.start();
t1.join(); // wait t1 to be finished
t2.start();
t2.join(); // in this program, this may be removed
}
}

作者: 何丛 时间: 2013-11-12 20:00
这个程序的执行顺序是这样的，如果线程ta先运行，则打印A，然后将线程tb的中断标志设置为true，自己调用join方法进入阻塞。在这里补充一句，interrupt()并不直接中断线程，而是设定中断标识为true，抛出异常进入catch语句块后中断标识重新置为false。如果线程tb接着运行，当tb运行到this.join方法时检查中断标志，因为之前已经置为true，这里会抛出异常进入catch语句块，并将自己的中断标志置为false，然后打印B，并将tc的中断标识置为true，tb继续运行会在this.join方法这里进入阻塞和tb一样。此时ta和tb都处于阻塞状态，tc获得执行权。tc中和tb一样，只是最后打印的是C，并且将ta的中断标志置为true，因为在join方法哪里会不断的检查中断标志，所以ta会抛出异常进入catch块继续执行，打印A后又将tb的中断标志置为true，沿着之前的顺序依次执行直到所有循环结束。由tb或者tc开始也是差不多的，lz可以按这种分析方法自己理一遍

作者: spiderman 时间: 2013-11-12 20:06

class Print implements Runnable
{
private String[] s={"A","B","C"};
private int i=0;
private int x=31;
public void run()
{
while(x>0)
{
synchronized(obj.a)
{
System.out.print(s[i]);
if(i<2)
i++;
else
i=i-2;
x--;
}
}
}
}
class obj
{
static Object a=new Object();
}
class Main
{
public static void main(String[] args)
{
Print p=new Print();
Thread A=new Thread(p);
Thread B=new Thread(p);
Thread C=new Thread(p);
A.start();
B.start();
C.start();
}
}

复制代码

不知道我这个符不符合你的题意？

作者: spiderman 时间: 2013-11-12 23:15
之前的那个应该不符合题意，这个肯定符合，就是有点变态，估计比他那个还难懂。。。。

作者: spiderman 时间: 2013-11-12 23:16
之前的那个应该不符合题意，这个肯定符合，就是有点变态，估计比他那个还难懂。。。。

import java.util.concurrent.locks.*;
class LockTest
{
private static ReentrantLock lock=new ReentrantLock();
private static Condition cd=lock.newCondition();
private static Condition cd1=lock.newCondition();
private static Condition cd2=lock.newCondition();
public static void main(String[] args)
{
Thread td1=new A();
Thread td2=new B();
Thread td3=new C();
td1.setName("A");
td2.setName("B");
td3.setName("C");
td3.start();
Thread.yield();
td2.start();
Thread.yield();
td1.start();
}
static class A extends Thread
{
public void run()
{
int x=0;
while(x<10)
{
lock.lock();
try
{
if(x!=0)
{
cd.await();
}
}
catch (Exception e)
{
}
System.out.print(Thread.currentThread().getName());
cd1.signal();
x++;
lock.unlock();
}
}
}
static class B extends Thread
{
public void run()
{
int x=0;
while(x++<10)
{
lock.lock();
try
{
cd1.await();
}
catch (Exception e)
{
}
System.out.print(Thread.currentThread().getName());
cd2.signal();
lock.unlock();
}
}
}
static class C extends Thread
{
public void run()
{
int x=0;
while(x++<10)
{
lock.lock();
try
{
cd2.await();
}
catch (Exception e)
{
}
System.out.print(Thread.currentThread().getName());
cd.signal();
lock.unlock();
}
}
}
}

复制代码

作者: spiderman 时间: 2013-11-12 23:40
刚刚做了下测试，你你贴出来的那个代码有陷入全部等待的状态，只是计算机执行速度特别快，所以发生的概率微乎其微，你在ta.start()方法后面加一个sleep(100)，效果一下就出来了,如下图

ta.start();
try
{
Thread.sleep(100);
}
catch (Exception e)
{
}
System.out.println("over");
tb.start();
tc.start();

复制代码

正确的写法应该是:

tb.start();
tc.start();
try
{
Thread.sleep(100);
}
catch (Exception e)
{
}
ta.start();

复制代码

时间可以再小一些，或者直接用yield()来代替应该也可以，不过时间越短，越有可能进入全部等待状态。

作者: spiderman 时间: 2013-11-12 23:47
至于你没理解那个代码，我觉得理解这两个方法的用法应该就能理解了：
1.this.join()：意思是当前线程进入等待状态。一般是A线程启动后，在A线程的线程内启动了B线程，这时B.join()就代表着A等着B结束，但是此时不代表着C、D、E、等等的线程也等着B结束。而在他这里比较特殊，本身等待本身结束，就代表着进入了死循环，或者就是等待的状态。
2.t.interrupt()：意思是接触t的冻结状态。比如调用过this.join方法的这样的线程，使用该方法后，就会解除无限等待状态，拥有执行资格。

作者: spiderman 时间: 2013-11-16 19:23
@黄炳期这个问题我回答的这么详细，怎么不给我分啊

作者: 黄炳期 时间: 2013-11-16 21:49

spiderman 发表于 2013-11-16 19:23
@黄炳期这个问题我回答的这么详细，怎么不给我分啊

提问结束的帖子不要再回答问题，不是说回答了就能得分的。你这隔了两天才回答问题

作者: spiderman 时间: 2013-11-16 21:54

黄炳期发表于 2013-11-16 21:49
提问结束的帖子不要再回答问题，不是说回答了就能得分的。你这隔了两天才回答问题 ...

噢。。这样。。。没留意。。。咳，白写了那么多。谢谢了哈

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

黑马程序员IT技术论坛 X3.2