各位大神看一下这个多线程同步有什么问题。

Question

package com.iweb.java;//编写一段代码，4个线程同时运行，2个线程对i加一,2个线程对i减一
public class Homework implements Runnable {
 int i =0;
static Object o1 = new Object();
static Object o2 = new Object();
static Object o3 = new Object();
static Object o4 = new Object();
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (o1) {
i++;
System.out.println(i++);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block e.printStackTrace();
synchronized (o1) {
i++;System.out.println(i++);}}}  
synchronized (o2) { i--;
System.out.println(i--);
try { Thread.sleep(1000);}
 catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (o2) {
i--; System.out.println(i--);
}}}}

Answer 1

你的输出结果是什么？个人猜测是2  4   2  0吧。你这里面只有两个线程在执行吧，就是o1和02，o1对i进行了四次加，输出语句里面i++算一次。o2对i进行了四次减。

Answer 2

package com.iweb.java;//编写一段代码，4个线程同时运行，2个线程对i加一,2个线程对i减一
public class Homework implements Runnable {
    int i = 0;
    static Object o1 = new Object();
    static Object o2 = new Object();
    static Object o3 = new Object();
    static Object o4 = new Object();    @Override
    public void run() {
// TODO Auto-generated method stub
        synchronized (o1) {
            i++;//这里i的值为1
            System.out.println(i++);//这里是打印输出i=1后,进行i++值变为2
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                synchronized (o1) {
                    i++;//这里你是放在catch里面的，没有异常不会执行
                    System.out.println(i++);//同上
                }
            }
        }
        synchronized (o2) {
            i--;//这里的值会变成1
            System.out.println(i--);//这里是打印输出i=1后,进行i--值变为0
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2) {
                i--;//这里的值为-1,
                System.out.println(i--);//这里是打印输出i=-1后,i--值变为-2
            }
        }
    }
}你如果想实现你所说的结果，得重新写

Answer 3

你对加用了同一个锁，2个加必然不会同时运行，同理2个减也是这样。你需要设置一个判断位，例如int i；当i=0时，加运行，减被停止，当i=4时 减运行，加被停止。

Answer 4

很简单的, 4个线程用线程控制变量
//可重用同步信号计数器
private static CountDownLatch signal1 = new CountDownLatch(1);
private static CountDownLatch signal2 = new CountDownLatch(1);
private static CountDownLatch signal3 = new CountDownLatch(1);
private static CountDownLatch signal4 = new CountDownLatch(1);第一个线程里, 运行前把 signal1变量放进去, 
第二个线程里, 运行前把 signal1, signal2, 变量放进去,  先执行 signal1.await() 这个代码只有在 第一个线程执行了: signal1.countDown(), 才会接着运行. 
第三个线程里, 运行前把 signal2, signal3, 变量放进去, 先执行 signal2.await() 这个代码只有在 第一个线程执行了: signal2.countDown(), 才会接着运行. 
第四个线程里, 运行前把 signal3, signal4, 变量放进去, 先执行 signal3.await() 这个代码只有在 第一个线程执行了: signal3.countDown(), 才会接着运行. 总程序: signal4.await(), 如果线程 4完成了 执行  signal4.countDown()

Answer 5

如果在运行N次, 可以再搞一个 CountDownLatch signal5 = new CountDownLatch(1);
每个线程, 执行完成后, 如果 signal5 没有 countDown() 全部等着.
总线程在 知道 线程 4运行完成后, 把 1-4重新new 一个新的:
signal1 = new CountDownLatch(1);
signal2 = new CountDownLatch(1);
signal3 = new CountDownLatch(1);
signal4 = new CountDownLatch(1);
然后进行下一次相减.
无穷无尽.....4个线程, 按顺序一个个执行.

Answer 6

CountDownLatch 是信号量计数对象, 是java线程并发里经常要用到的.楼主可以慢慢研究一下.
signal4.await() 就是如果计数没有完, 就自己等待.
signal4.countDown() 就是计数减少1, 上面创建就是1, 如果减一次就是0, 也就是告诉 await 不要再等了, 可以往下走了.
把  await() , 与  countDown() 放在不同的线程中操作, 这样就变成了线程等待.