public class ThreadTest4 {

        /**
         * 定义四个线程，2个线程对J++，2个线程对J--
         */
        private static int j = 0;(这里这与写)
        private int j = 0;这么写有区别么。
        还有 下面dec   和 inc 不加synchronized呢~~~
        public static void main(String[] args) {
                Thread t;
                Inc inc = new ThreadTest4().new Inc();
                Dec dec = new ThreadTest4().new Dec();
                for(int i=0; i<2; i++)
                {
                        t = new Thread(inc);
                        t.start();
                        t = new Thread(dec);
                        t.start();
                }
        }
        public synchronized void inc()
        {
                j++;
                System.out.println(Thread.currentThread().getName()+"---inc:"+j);
        }
        public 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++)
                        {
                                new ThreadTest4().inc();
                        }
                }
        }
        class Dec implements Runnable
        {
                public void run() {
                        for(int i=0; i<100; i++)
                        {
                                new ThreadTest4().dec();
                        }
                }
        }
}
我们来积极讨论一下啊。。。

  class Inc implements Runnable
        {
                public void run() {
                        for(int i=0; i<100; i++)
                        {
                               new ThreadTest4().inc();//这里每次都会new一个新对象，如果老是new新对象，变量不写static，每个对象都打印自己的j，每个对象调用.inc()是1，因为每个对象只调用一次，下次就是另一个新对象调用了；dec   inc 加不加synchronized关系不大，只是打印的顺序上会有差别。打印的数据还是一样的~~~因为他们是不同的对象，虽然有相同的锁，但是每次都是新的对象调用对于变量不加static来说打印的都是对象自己的数据。
                        }
                }
        }
        class Dec implements Runnable
        {
                public void run() {
                        for(int i=0; i<100; i++)
                        {
                                new ThreadTest4().dec();//同上，dec()是-1；
                        }
                }
        }

刘军亭 发表于 2013-1-22 19:39
class Inc implements Runnable
        {
                public void run() {

你把几种方法都实践一下，，，

private static int j = 0;(这里这与写)
        private int j = 0;这么写有区别么。
    上面的j是本类和本类的子类的共享数据,
      下面的j是每创建一个本类或本类的子类对象,都会拥有不同的j变量

还有 下面dec   和 inc 不加synchronized呢~~~
      如果dec   和 inc 不加synchronized,那样打印出的数据会错乱,
      比如j=1时,1线程刚执行了j++后,还没有打印输出,2线程获得了cpu执行权,又执行了j++,并输出了j=3,而这个时候1线程又抢到了cpu执行权,这时1线程继续没有执行的打印操作,而这时j的值已经变为了3,打印出的也就是3,2却没有打印出来,
    如果打个比方的话就是,你在一家公司工作,有一份工作还没有完成,但你却临时有急事需要处理,请了长假.可这时你的位置却被人顶替了,等你回来时,什么都和以前不一样了,这时就出现了错乱

黑马唐贤来 发表于 2013-1-22 20:09
private static int j = 0;(这里这与写)
        private int j = 0;这么写有区别么。
    上面的j是本类和 ...

如果变量j不是静态共享数据，加不加synchronized都是一样的，只是打印顺序会错乱。因为不能同步。对打印的数据是不会有影响的因为他们每次都是创建一个新对象去调用的。
如果变量 j 是共享数据的话，那就有点麻烦了，就算是不同的对象调用，但是每个新对象调用都会修改全局变量的值。所以下一次在一个新对象调用就会使修改后的值了。

高兴啊，终于加了一个技术分了，这么多天第一个技术分啊，{:soso_e113:}

刘军亭 发表于 2013-1-22 20:22
如果变量j不是静态共享数据，加不加synchronized都是一样的，只是打印顺序会错乱。因为不能同步。对打印 ...

楼主英明...

这个题目有点意思啊，如果static 后在同步话，有可能出现死循环吧