A股上市公司传智教育（股票代码 003032）旗下技术交流社区北京昌平校区

传智教育官网黑马程序员官网

 找回密码
 加入黑马

QQ登录

只需一步，快速开始

论坛首页 › 隐藏归类 › 黑马那些年 › 第30,31届Android交流区 › 正文

让2个线程按顺序打印

© 吴光新 黑马帝   /  2014-2-15 03:12  /  1892 人查看  /  18 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 吴光新 于 2014-2-15 03:16 编辑

public class Test1 {
private A a;
private B b;

public static void main(String[] args){
  Test1 t = new Test1();
  t.show();
}

public void show(){
  a = new A();
  b = new B();
  a.start();
  b.start();
}

class A extends Thread{
  @Override
  public void run() {
   for (int i = 1; i < 100; i+=2) {
    System.out.println("A=" + i);
   }
  }
}
class B extends Thread{
  @Override
  public void run() {
   for (int i = 0; i < 100; i+=2) {
    System.out.println("B=" + i);
   }
  }
}
}



打印结果是
A=1
A=3
A=5
B=0
A=7
A=9
A=11
A=13
....

请修改程序，让两个线程同时打印
A=1
B=2
A=3
B=4
A=5
B=6
......

回答正确，前三名 各奖励2技术分

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

18 个回复

倒序浏览
小Zeor……… 中级黑马 2014-2-15 08:35:45
| 只看该作者
沙发
本帖最后由 小Zeor……… 于 2014-2-15 10:27 编辑

抢沙发，应该是线程加锁的问题。占个位置一会贴出来解答，有技术分 ，哇咔咔
  1. public class Test1 {
  2.         private A a;
  3.         private B b;
  4.         private R r;

  6.         public static void main(String[] args) {
  7.                 Test1 t = new Test1();
  8.                 t.show();
  9.         }

  11.         public void show() {
  12.                 r = new R();
  13.                 a = new A();
  14.                 b = new B();
  15.                 Thread t1 = new Thread(a);
  16.                 Thread t2 = new Thread(b);
  17.                 t1.start();
  18.                 t2.start();
  19.         }

  21.         class R {
  22.                 boolean flag = true;
  23.         }

  25.         class A extends Thread {
  26.                 @Override
  27.                 public void run() {
  28.                         int i = 0;
  29.                         while (i < 100) {
  30.                                 {
  31.                                         if (r.flag) {
  32.                                                 synchronized(r){System.out.println("A=" + i);
  33.                                                 i++;
  34.                                                 i++;
  35.                                                 r.flag = false;
  36.                                                 }
  37.                                         }
  38.                                 }
  39.                         }
  40.                 }
  41.         }

  43.         class B extends Thread {
  44.                 @Override
  45.                 public void run() {
  46.                         int i = 1;
  47.                         while (i < 100) {
  48.                                 if (!r.flag) {
  49.                                         synchronized (r) {
  50.                                                 System.out.println("B=" + i);
  51.                                                 i++;
  52.                                                 i++;
  53.                                                 r.flag = true;
  54.                                         }
  55.                                 }

  57.                         }
  58.                 }
  59.         }
  60. }
复制代码


点评

吴光新
请Q我索取奖励  发表于 2014-2-19 19:52

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

回复 使用道具 举报
分解式 中级黑马 2014-2-15 09:05:49
| 只看该作者
藤椅
求技术分
回复 使用道具 举报
奋斗的小胖子 中级黑马 2014-2-15 09:17:00
| 只看该作者
板凳
本帖最后由 奋斗的小胖子 于 2014-2-15 09:44 编辑
  1. public class Test1
  2. {
  3.          public static void main(String[] args)
  4.          {
  5.                  show s1=new show();
  6.                  A a1=new A(s1);
  7.                  B b1=new B(s1);
  8.                  Thread t1=new Thread(a1);
  9.                  Thread t2=new Thread(b1);
  10.                  t1.start();
  11.                  t2.start();
  12.                  
  13.          }
  14.                
  15. }
  16.          
  17.          
  18. class show
  19. {
  20.         private show s;
  21.         int num=0;
  22.         private boolean flag=false;
  23.         show(){}
  24.         Lock lock=new ReentrantLock();
  25.         Condition  A_lock=lock.newCondition();
  26.         Condition  B_lock=lock.newCondition();
  27.         public void showA()
  28.         {
  29.                 lock.lock();
  30.                 try {
  31.                        
  32.                        
  33.                         while(flag==true)
  34.                         {
  35.                                 A_lock.await();
  36.                                 if(num<100)
  37.                                 {
  38.                                         num++;
  39.                                         System.out.println("A="+num);
  40.                                 }
  41.                         }
  42.                         flag=true;
  43.                         B_lock.signal();
  44.                 }
  45.                 catch (InterruptedException e) {
  46.                         // TODO Auto-generated catch block
  47.                         e.printStackTrace();
  48.                 }
  49.                 finally
  50.                 {
  51.                         lock.unlock();
  52.                 }
  53.         }

  55.         public void showB()
  56.         {
  57.                 lock.lock();
  58.                 try {
  59.                        
  60.                        
  61.                         while(flag==false)
  62.                         {
  63.                                 B_lock.await();
  64.                                 if(num<100)
  65.                                 {
  66.                                         num++;
  67.                                         System.out.println("B="+num);
  68.                                 }
  69.                         }
  70.                         flag=false;
  71.                         A_lock.signal();
  72.                 }
  73.                 catch (InterruptedException e) {
  74.                         // TODO Auto-generated catch block
  75.                         e.printStackTrace();
  76.                 }
  77.                 finally
  78.                 {
  79.                         lock.unlock();
  80.                 }
  81.         }
  82. }
  83. class A implements Runnable
  84. {
  85.         show s;
  86.         public A(show s)
  87.         {
  88.                 this.s=s;
  89.         }
  90.         public void run()
  91.         {
  92.                 while(true)
  93.                 {
  94.                         s.showA();
  95.                 }
  96.         }
  97. }
  98. class B implements Runnable
  99. {
  100.         show s;
  101.         public B(show s)
  102.         {
  103.                 this.s=s;
  104.         }
  105.         public void run()
  106.         {
  107.                 while(true)
  108.                 {
  109.                         s.showB();
  110.                 }
  111.         }
  112. }
复制代码

我是参考生产消费的例子写的，为了抢楼没写注释，就先发了

点评

吴光新
请Q联系我索取奖励  发表于 2014-2-19 19:48

评分

参与人数 1技术分 +2 收起 理由
zzkang0206 + 2

查看全部评分

回复 使用道具 举报
LSCZ3633 中级黑马 2014-2-15 09:29:00
| 只看该作者
报纸
  1. package com.itheima;
  2. /*
  3. * 使两个线程一个一个有序进行
  4. *
  5. * 思路：定义一个标签boolean  判断哪个线程应该执行
  6. * 定义一个公共变量i
  7. * 加入一个同步代码块 synchronized(r)
  8. *
  9. *
  10. *
  11. * */


  14. public class Test1 {
  15. private A a;
  16. private B b;
  17. private R r;
  18. public static void main(String[] args){
  19.          
  20.     Test1 t = new Test1();
  21.    t.show();
  22. }

  24. public void show(){
  25.    r=new R();
  26.          a = new A(r);
  27.    b = new B(r);
  28.   
  29.    a.start();
  30.    b.start();
  31. }
  32. }
  33. class R{
  34.         int i=1;
  35.         boolean flag=true;
  36.        
  37.         R(){}
  38.        
  39. }
  40. class A extends Thread{
  41.          private R r;
  42.          A(R r){
  43.                  this.r=r;
  44.          }
  45.          @Override
  46.    public void run() {
  47.    
  48.                  for (; r.i < 100; ) {
  49.                          
  50.                          if(r.flag){
  51.                                  synchronized(r){
  52.                                          System.out.println("A=" + r.i++);
  53.                                          r.flag=false;
  54.                                  }
  55.                                  
  56.                                  }
  57.    
  58.      
  59.     }
  60.    }
  61. }

  63. class B extends Thread{
  64.          private R r;
  65.          B(R r){
  66.                  this.r=r;
  67.          }
  68.          @Override
  69.    public void run() {
  70.     for (; r.i < 100; ) {
  71.             if(!r.flag){
  72.                      synchronized(r){
  73.                     System.out.println("B=" + r.i++);
  74.                      r.flag=true;
  75.                      }
  76.             }
  77.    
  78.    
  79.     }
  80.    }
  81. }
复制代码

点评

吴光新
请Q我索取奖励  发表于 2014-2-19 19:53

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

回复 使用道具 举报
LuckyQS 中级黑马 2014-2-15 09:45:56
| 只看该作者
地板
public class Test1 {
        private A a;
        private B b;
        private R r;
        public static void main(String[] args){
                Test1 t = new Test1();
                t.show();
        }
        public void show(){
                r=new R();
                a = new A(r);
                b = new B(r);
                a.start();
                b.start();
        }
}
class R{
        int i=1;
        boolean flag=true;
        R(){}      
}
class A extends Thread{
        private R r;
        A(R r){
                this.r=r;
        }
        @Override
        public void run() {
                while(r.i<100) {   
                        if(r.flag){
                                synchronized(r){
                                        System.out.println("A="+r.i++);
                                        r.flag=false;
                                }                        
                        }
                }
        }
}
class B extends Thread{
        private R r;
        B(R r){
                this.r=r;
        }
        @Override
        public void run() {
        while(r.i<100) {
                if(!r.flag){
                        synchronized(r){
                                System.out.println("B="+r.i++);
                                r.flag=true;
                                }
                        }
                }
        }
}
只要让两个线程控制同一份元素,定义一个boolean变量来改变线程的执行权

点评

吴光新
请Q我索取奖励  发表于 2014-2-19 19:49

评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

回复 使用道具 举报
倉促、尋找你 来自手机 中级黑马 2014-2-15 09:47:06
| 只看该作者
7#
手机回复，就不贴代码了，线程同步建议使用实现Runnable接口的方法去做这个题目不难，你搜一下资料应该就搞定了
回复 使用道具 举报 1 0
孤独的天奇 中级黑马 2014-2-15 11:15:29
| 只看该作者
8#
奋斗的小胖子 发表于 2014-2-15 09:17
我是参考生产消费的例子写的，为了抢楼没写注释，就先发了

嗯，我觉得，就应该是这样子。
回复 使用道具 举报
孤独的天奇 中级黑马 2014-2-15 19:20:16
| 只看该作者
9#
package com.itheima;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Resource {
       
        Lock lock = new ReentrantLock();
        boolean flag = false;
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
       
        public void printA(){
                lock.lock();
                try {
                        for (int i = 1; i <= 100; i+=2) {
                                while(flag)
                                        conditionA.await();
                            System.out.println("A=" + i);
                            flag = true;
                            conditionB.signal();
                           }
                } catch (Exception e) {
                        // TODO: handle exception
                }finally{
                        lock.unlock();
                }
               
        }
package com.itheima;

public class A implements Runnable{
       
        private Resource res;
       
        public A(Resource res){
                this.res = res;
        }

        @Override
        public void run() {
                res.printA();
               
        }
}

package com.itheima;

public class B implements Runnable {

        private Resource res;
       
        public B(Resource res){
                this.res = res;
        }
       
        @Override
        public void run() {
                res.printB();
        }

}

package com.itheima;

public class Test {

        /**
         * @param args
         */
        public static void main(String[] args) {
                Resource res = new Resource();
                new Thread(new A(res)).start();
                new Thread(new B(res)).start();

        }

}


评分

参与人数 1技术分 +1 收起 理由
zzkang0206 + 1

查看全部评分

回复 使用道具 举报
孤独的天奇 中级黑马 2014-2-15 19:22:20
| 只看该作者
10#
package com.itheima;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Resource {
       
        Lock lock = new ReentrantLock();
        boolean flag = false;
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
       
        public void printA(){
                lock.lock();
                try {
                        for (int i = 1; i <= 100; i+=2) {
                                while(flag)
                                        conditionA.await();
                            System.out.println("A=" + i);
                            flag = true;
                            conditionB.signal();
                           }
                } catch (Exception e) {
                        // TODO: handle exception
                }finally{
                        lock.unlock();
                }
               
        }
       
        public void printB(){
                lock.lock();
                try {
                        for (int i = 2; i <= 100; i += 2) {
                                while(!flag)
                                        conditionB.await();
                                System.out.println("B=" + i);
                                flag = false;
                            conditionA.signal();
                        }
                } catch (Exception e) {
                        lock.unlock();
                }
        }
}

Resource 类没有发全，补上
回复 使用道具 举报
小Zeor……… 中级黑马 2014-2-15 20:37:15
| 只看该作者
11#
@吴光新 求加分。。。。要下一步考试。。
回复 使用道具 举报
奋斗的小胖子 中级黑马 2014-2-19 20:06:27
| 只看该作者
12#
QQ多少啊？  什么奖励啊？
回复 使用道具 举报
奋斗的小胖子 中级黑马 2014-2-19 20:16:37
| 只看该作者
13#
没有权限啊
回复 使用道具 举报
奋斗的小胖子 中级黑马 2014-2-19 20:19:14
| 只看该作者
14#


请修改我的权限
回复 使用道具 举报
wh963572516 中级黑马 2014-2-21 15:45:09
| 只看该作者
15#
自己写的，不知道对不对，我自己验证的是和你要求的一样
  1. //公共资源
  2. class Resource
  3. {
  4.         public int i = 1;
  5. }

  7. //线程 1
  8. class Thread1 implements Runnable {
  9.         private Resource r;

  11.         public Thread1(Resource r) {  
  12.                 this.r = r;
  13.         }

  15.         public void run() {  
  16.                         synchronized (r) {   
  17.                                 while(r.i<100){
  18.                                         System.out.println("A="+r.i);
  19.                                         r.i++;
  20.                                         r.notify();//唤醒
  21.                                         try{
  22.                                                 r.wait();//等待
  23.                                         }catch (InterruptedException e) {     
  24.                                                 e.printStackTrace();
  25.                                         }
  26.                                 }
  27.                         }
  28.         }
  29. }

  31. //线程2
  32. class Thread2 implements Runnable {
  33.         private  Resource r;
  34.         public Thread2(Resource r) {
  35.                 this.r = r;
  36.         }
  37.         public void run() {
  38.                 synchronized (r) {
  39.                         while(r.i <100){  
  40.                                 System.out.println("B="+r.i);
  41.                                 r.i++;
  42.                                 r.notify();//唤醒
  43.                                 try {
  44.                                         r.wait();//等待
  45.                                 }catch (InterruptedException e) {     
  46.                                         e.printStackTrace();
  47.                                 }
  48.                         }
  49.                 }
  50.         }
  51. }

  53. //主线程
  54. public class ThreadDemo6{
  55.         public static void main(String[] args){
  56.                 Resource r =new Resource();
  57.                 Thread t1=new Thread(new Thread1(r));
  58.                 Thread t2=new Thread(new Thread2(r));
  59.                 t1.start();
  60.                 t2.start();
  61.         }
  62. }
复制代码
回复 使用道具 举报
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 加入黑马