求：多线程高手！！很纠结。。。。

Question

有这么个题目：
一个线程不停地生产玩家，一个线程不停地生产怪物，然后都放在一个容器里面去。当容器中的玩家和怪物总数超过10万的时候，全部停止。
只有一个要求：打印true。
哥们调试了大半天了，每个头绪，气死我了，各位帮着改改。
建一个类 叫：GoToHell 直接把代码copy进去调试吧。public class GoToHell {
private static abstract class BaseClass {
public BaseClass() { }
} public static class Player extends BaseClass { } public static class Monster extends BaseClass { } private static boolean con = true;
//新的集合
private static Collection<BaseClass> newList = Collections
.synchronizedCollection(new ArrayList<BaseClass>());
//总的集合
private static Collection<BaseClass> allList = new ArrayList<BaseClass>(); //玩家总数
private static int playerNum;
//怪物总数
private static int monsterNum; public static void main(String[] args) {
new Thread() {
public void run() {
while (con) {
newList.add(new Player());
playerNum++;
} }
}.start(); new Thread() {
public void run() {
while (con) {
newList.add(new Monster());
monsterNum++;
}
}
}.start(); new Thread() {
public void run() {
while (con) {
if(!newList.isEmpty()){
allList.addAll(newList);
newList.clear();
}
if(allList.size() > 100000){
con = false;
}
}
//要求这里 打印：true
System.out.println(playerNum + monsterNum == allList.size());
System.out.println(playerNum);
System.out.println(monsterNum);
System.out.println(allList.size());
}
}.start();
}}

Answer 1

public class GoToHell {    private static Collection<BaseClass> allList = new ArrayList<BaseClass>();
    
    private static abstract class BaseClass {
        public BaseClass() {}
    }    public static class Player extends BaseClass {}    public static class Monster extends BaseClass {}
    
public static void main(String[] args) {
new Thread() {
public void run() {
while (true) {
add(new Player());
}
}
}.start(); new Thread() {
public void run() {
while (true) {
add(new Monster());
}
}
}.start();
}    private static synchronized void add(BaseClass base){
     if(allList.size()<1000){
     allList.add(base);
     }else{
     System.out.println("true");
     }
    }
}

Answer 2

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;public class GoToHell {
    private static abstract class BaseClass {
        public BaseClass() {        }
    }    public static class Player extends BaseClass {    }    public static class Monster extends BaseClass {    }    private static boolean con = true;
    //新的集合
    private static Collection<BaseClass> newList = Collections
            .synchronizedCollection(new ArrayList<BaseClass>());
    //总的集合
    private static Collection<BaseClass> allList = new ArrayList<BaseClass>();    //玩家总数
    private static int playerNum;
    //怪物总数
    private static int monsterNum;    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while (con) {
                    newList.add(new Player());
                    playerNum++;
                }            }
        }.start();        new Thread() {
            public void run() {
                while (con) {
                    newList.add(new Monster());
                    monsterNum++;
                }
            }
        }.start();        new Thread() {
            public void run() {
                while (con) {
                 if (newList.size()>100000) {
                  con = false;
}
                    /*if(!newList.isEmpty()){
                        allList.addAll(newList);
                        newList.clear();
                    }
                    if(allList.size() > 100000){
                        con = false;
                    }*/
                }
                //要求这里 打印：true
                System.out.println(playerNum + monsterNum == newList.size());
                System.out.println(playerNum);
                System.out.println(monsterNum);
                System.out.println(newList.size());
            }
        }.start();
    }}

Answer 3

要是想线程停止的话就把
private static synchronized void add(BaseClass base){
改成
private static synchronized boolean add(BaseClass base){
传给while停止循环，就可以了

Answer 4

你这个没法精确到 true，如果想要精确的话 只能把第三个线程的判断放到强两个线程里面，每次++的时候都判断一次~

Answer 5

3楼的兄弟改动大了 而且不太精确的true 偶尔还有false
5喽的兄弟说的可以考虑一下

Answer 6

根据楼主的编程思路，更改如下：package houlei.csdn.mutiThreads;import java.util.ArrayList;
import java.util.Collection;/**
 * 有这么个题目： 一个线程不停地生产玩家，一个线程不停地生产怪物，然后都放在一个容器里面去。<br/>
 * 当容器中的玩家和怪物总数超过10万的时候，全部停止。<p/> 只有一个要求：打印true。
 * 
 * @author HouLei
 * 
 */
public class GoToHell {
private static abstract class BaseClass {
} public static class Player extends BaseClass {
} public static class Monster extends BaseClass {
} // 总的集合
private Collection<BaseClass> allLives = new ArrayList<BaseClass>(100100); // 玩家总数
private int playerNum; // 怪物总数
private int monsterNum; public synchronized void add(BaseClass life) {
if (life instanceof Player) {
playerNum++;
}
if (life instanceof Monster) {
monsterNum++;
}
allLives.add(life);
} public synchronized int getMonsterNum() {
return monsterNum;
} public synchronized int getPlayerNum() {
return playerNum;
} public synchronized int getLivesCount() {
return allLives.size();
} /**
 * 可以统一结束的线程抽象类。
 * 通过使用内部的<code>running</code>变量，实现所有实现类线程的结束。
 */
abstract static class UnityThread extends Thread {
protected static boolean running = true; protected void shutdownAll() {
running = false;
}
} public static void main(String[] args) {
final GoToHell Hell = new GoToHell();
final int MaxLives = 100000; new UnityThread() {
public void run() {
while (running) {
Hell.add(new Player());
Thread.yield();
}
}
}.start(); new UnityThread() {
public void run() {
while (running) {
Hell.add(new Monster());
Thread.yield();
}
}
}.start(); new UnityThread() {
public void run() {
while (running) {
if (Hell.getLivesCount() > MaxLives) {
shutdownAll();
} else {
Thread.yield();
}
}
// 要求这里 打印：true
System.out.println(Hell.getPlayerNum() + Hell.getMonsterNum() == Hell.getLivesCount());
System.out.println(Hell.getPlayerNum());
System.out.println(Hell.getMonsterNum());
System.out.println(Hell.getLivesCount());
}
}.start(); }}

Answer 7

大致看了一下，楼主说超过10W，并不是，等于10W，那，按道理来讲，就没必要非得10W不可了。
如果可能20W，200W，... ... 也属于超过10W的范畴。嗯~~~
是不是很猥琐 ？

Answer 8

BlockingDeque import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;public class GoToHell {
    private static abstract class BaseClass {
        public BaseClass() {        }
    }    public static class Player extends BaseClass {    }    public static class Monster extends BaseClass {    }    private static boolean con = true;
    //新的集合
    private static Collection<BaseClass> newList = Collections
            .synchronizedCollection(new ArrayList<BaseClass>());
    
    private static BlockingDeque bq = new LinkedBlockingDeque(100000);
    //总的集合
    private static Collection<BaseClass> allList = new ArrayList<BaseClass>();    //玩家总数
    private static int playerNum;
    //怪物总数
    private static int monsterNum;    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            public void run() {
                while (con) {
                 try{
                 bq.add(new Player());
                  playerNum++;
                 }catch(java.lang.IllegalStateException e){
                 con = false;
                 }
                
                   
                }            }
        };
        t1.start();        Thread t2 = new Thread() {
            public void run() {
                while (con) {
                 try{
                 bq.add(new Monster());
                 monsterNum++;
                 }catch(java.lang.IllegalStateException e){
                 con = false;
                 }
                }
            }
        };
        t2.start();        t1.join();
        t2.join();
       
        //要求这里 打印：true
        System.out.println(playerNum + monsterNum == allList.size());
        System.out.println(playerNum);
        System.out.println(monsterNum);
        System.out.println(bq.size());
    }}

Answer 9

BlockingDeque import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;public class GoToHell {
    private static abstract class BaseClass {
        public BaseClass() {        }
    }    public static class Player extends BaseClass {    }    public static class Monster extends BaseClass {    }    private static boolean con = true;
    //新的集合
    private static Collection<BaseClass> newList = Collections
            .synchronizedCollection(new ArrayList<BaseClass>());
    
    private static BlockingDeque bq = new LinkedBlockingDeque(100000);
    //总的集合
    private static Collection<BaseClass> allList = new ArrayList<BaseClass>();    //玩家总数
    private static int playerNum;
    //怪物总数
    private static int monsterNum;    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            public void run() {
                while (con) {
                 try{
                 bq.add(new Player());
                  playerNum++;
                 }catch(java.lang.IllegalStateException e){
                 con = false;
                 }
                
                   
                }            }
        };
        t1.start();        Thread t2 = new Thread() {
            public void run() {
                while (con) {
                 try{
                 bq.add(new Monster());
                 monsterNum++;
                 }catch(java.lang.IllegalStateException e){
                 con = false;
                 }
                }
            }
        };
        t2.start();        t1.join();
        t2.join();
       
        //要求这里 打印：true
        System.out.println(playerNum + monsterNum == allList.size());
        System.out.println(playerNum);
        System.out.println(monsterNum);
        System.out.println(bq.size());
    }}