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);
                }
        }
}

LZ感觉你这个思路有点乱，我给你写了个你看看对不。

1. package test;
   
2. 
   
3. 
   
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. }
    
19. 
    
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. }

复制代码

基本类型的参数传递是把实际的值复制一份给另一个变量，你的程序中两个Runnable都通过构造函数传入参数，等于是有两份数据，线程执行的不是一份数据，如果你想操作同一份数据，这样做显然是不对的，

周建 发表于 2012-3-20 21:13
基本类型的参数传递是把实际的值复制一份给另一个变量，你的程序中两个Runnable都通过构造函数传入参数，等 ...

好像是有一点   按照楼上同学的那样  设计应该是可以的  你觉得呢

靠谱  ，莫非是高手？

周建 发表于 2012-3-20 23:11
靠谱  ，莫非是高手？

只是有一点   它的int i  不应该设计成 static的了  这样声明周期太长了

张锐 发表于 2012-3-20 20:01
LZ感觉你这个思路有点乱，我给你写了个你看看对不。

嗯ok  只是  int  i  这个最好别是静态的  我觉得就用 全局实例变量即可了， 你觉得呢？

因为建了两个runnable，所以用static保证两个用的是一份数据。

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();
                    }
                }
        }
}