黑马程序员技术交流社区

标题: 设计4个线程，其中两个每次对j加1，另外两个j每次减1，这样设计是否正确呢 [打印本页]
作者: lucky_xingxing    时间: 2012-3-20 19:37
标题: 设计4个线程，其中两个每次对j加1，另外两个j每次减1，这样设计是否正确呢
public class  ThreadTest
{
        public static void main(String [] args){
                int i = 100;
                ThreadAdd add = new ThreadAdd(i);
                ThreadCut cut = new ThreadCut(i);
                Thread t1 = new Thread(add);
                Thread t2 = new Thread(add);
                Thread t3 = new Thread(cut);
                Thread t4 = new Thread(cut);
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}

class ThreadAdd implements Runnable
{
        private int i;
        public ThreadAdd(int i){
                this.i = i;
        }
                Object  obj = new Object();
        public void run(){
                for(int j = 0;j<50;j++){
                        synchronized(obj){               
                                i++;
                        }
                        System.out.println(i);
                }
        }
}

class ThreadCut implements Runnable
{
        private int i;
        public ThreadCut(int i){
                this.i = i;
        }
        Object  obj = new Object();
        public void run(){
                for(int j = 0;j<50;j++){
                        synchronized(obj)        {               
                                i--;
                        }
                                System.out.println(i);
                }
        }
}
作者: 张锐    时间: 2012-3-20 20:01
LZ感觉你这个思路有点乱，我给你写了个你看看对不。
  1. package test;


  4. public class  Lianxi
  5. {
  6.         public static void main(String [] args){
  7.                 Num add = new Num(true);
  8.                 Num cut = new Num(false);
  9.                 Thread t1 = new Thread(add);
  10.                 Thread t2 = new Thread(add);
  11.                 Thread t3 = new Thread(cut);
  12.                 Thread t4 = new Thread(cut);
  13.                 t1.start();
  14.                 t2.start();
  15.                 t3.start();
  16.                 t4.start();
  17.         }
  18. }

  20. class Num implements Runnable
  21. {
  22.         static int i = 100;
  23.         boolean flag = false;
  24.         public Num(boolean flag){
  25.                 this.flag = flag;
  26.         }
  27.         public void run(){
  28.                 if (flag) {
  29.                         for(int j = 0;j<50;j++){
  30.                         synchronized(Lianxi.class){               
  31.                                 i++;
  32.                                 System.out.println(Thread.currentThread().getName()+"----"+i);
  33.                                 }      
  34.                         }
  35.                 }
  36.                 if (!flag) {
  37.                         for(int j = 0;j<50;j++){
  38.                         synchronized(Lianxi.class){               
  39.                                 i--;
  40.                                 System.out.println(Thread.currentThread().getName()+"----"+i);  
  41.                                 }      
  42.                         }
  43.                 }
  44.                
  45.         }
  46.         
  47. }
复制代码
作者: 周建    时间: 2012-3-20 21:13
基本类型的参数传递是把实际的值复制一份给另一个变量，你的程序中两个Runnable都通过构造函数传入参数，等于是有两份数据，线程执行的不是一份数据，如果你想操作同一份数据，这样做显然是不对的，
作者: lucky_xingxing    时间: 2012-3-20 22:54
周建 发表于 2012-3-20 21:13
基本类型的参数传递是把实际的值复制一份给另一个变量，你的程序中两个Runnable都通过构造函数传入参数，等 ...

好像是有一点   按照楼上同学的那样  设计应该是可以的  你觉得呢
作者: 周建    时间: 2012-3-20 23:11
靠谱  ，莫非是高手？
作者: lucky_xingxing    时间: 2012-3-21 08:04
周建 发表于 2012-3-20 23:11
靠谱  ，莫非是高手？

只是有一点   它的int i  不应该设计成 static的了  这样声明周期太长了
作者: lucky_xingxing    时间: 2012-3-21 08:05
张锐 发表于 2012-3-20 20:01
LZ感觉你这个思路有点乱，我给你写了个你看看对不。

嗯ok  只是  int  i  这个最好别是静态的  我觉得就用 全局实例变量即可了， 你觉得呢？
作者: 张锐    时间: 2012-3-21 08:13
因为建了两个runnable，所以用static保证两个用的是一份数据。
作者: 黑马胡林    时间: 2012-3-21 13:14
package Thread;

public class Tongbu{
    private int j;
    public static void main(String args[]){
            Tongbu tt=new Tongbu();
            //实例化俩个线程
            Inc inc=tt.new Inc();
            Dec dec=tt.new Dec();
            //启动线程
            for(int i=0;i<2;i++){  
                    Thread t=new Thread(inc);
                    t.start();
                    t=new Thread(dec);
                    t.start();
                    }
            }   
    //线程增
    private synchronized void inc(){
            j++;  
            System.out.println(Thread.currentThread().getName()+"-inc:"+j);
            }
    //纯种减
    private synchronized void dec(){
            j--;  
            System.out.println(Thread.currentThread().getName()+"-dec:"+j);
            }
//线程增
class Inc implements Runnable{
        public void run(){
                for(int i=0;i<100;i++){
                        inc();
                        }
                }
        }
//线程减
class Dec implements Runnable{
        public void run(){
                for(int i=0;i<100;i++){
                        dec();
                    }
                }
        }
}





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