求大神！！！ js猜数字游戏让电脑去猜人去输入判断结果_javascript吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：141,734贴子：
求大神！！！ js猜数字游戏让电脑去猜人去输入判断结果收藏
javascript 在线咨询领取笔试题目和试听资料!海同科技是您贴心的IT培训机构!上海海同科技:包食宿,零压力,模拟面试,轻松入职百强企业!
&span&猜数字游戏(1~100)&/span&&br/&
&p&您有10次猜数字的机会！&/p&
&input type=&text&&
&input type=&button& value=&确定&&
var num = getRandom(0, 101);
document.title =
var p = document.getElementsByTagName('p')[0];
var input = document.getElementsByTagName('input');
var step = 10;
input[1].onclick = function() {
var val = input[0].
if(step == 0) {
alert(&失败！没有机会可用了！&);
if(val == '') {
alert(&不能为空！&);
if(isNaN(Number(val))) {
alert(&请填数字！&);
} else if(val & num) {
alert(&数字太大了！&);
} else if(val & num) {
alert(&数字太小了！&);
p.innerHTML = '恭喜您猜对了！';
p.innerHTML = '错误，您还有' + step + '次机会！';
function getRandom(one, two) {
return Math.floor(Math.random() * (two - one) + one);
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或君，已阅读到文档的结尾了呢~~
多线程猜数字游戏实验报告
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
多线程猜数字游戏实验报告
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer--144.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口四个线程t1,t2,t3,t4,向4个文件中写入数据，t1只能写入1，t2只能写入2，t3只能写入3，t4只能写入4，对4个文件A，B，C，D写入如下内容:
怎么实现同步可以让线程并行工作？
这个用java语言怎么实现呢，希望有代码噢，期待答案，多谢！
回复讨论(解决方案)
看都没看懂..
总觉得这题有坑：用所谓的多线程来串行执行文件打印操作。
或者说题目里有些隐含条件没看出来？
总觉得这题有坑：用所谓的多线程来串行执行文件打印操作。
或者说题目里有些隐含条件没看出来？
感觉这就是面试官想要考察的，考察你对线程执行的控制程度。
来个暴力恶心的。。。完全不考虑什么代码优美和扩展性。只是保证符合题意并线程安全。大家看看有没有问题。
&*&To&change&this&license&header,&choose&License&Headers&in&Project&Properties.
&*&To&change&this&template&file,&choose&Tools&|&Templates
&*&and&open&the&template&in&the&editor.
package&com.hs.test.
import&java.io.StringW
import&java.util.concurrent.CountDownL
&*&@author&山
public&class&FourThreadsWriteFourFiles&{
&&&&static&CountDownLatch&cdl&=&new&CountDownLatch(4);
&&&&static&StringWriter[]&fourFiles&=&new&StringWriter[4];
&&&&static&{
&&&&&&&&fourFiles[0]&=&new&StringWriter();
&&&&&&&&fourFiles[1]&=&new&StringWriter();
&&&&&&&&fourFiles[2]&=&new&StringWriter();
&&&&&&&&fourFiles[3]&=&new&StringWriter();
&&&&volatile&int&flagA&=&4;&
&&&&volatile&int&flagB&=&1;
&&&&volatile&int&flagC&=&2;
&&&&volatile&int&flagD&=&3;
&&&&public&void&initThreads(){
&&&&&&&&Thread&tA&=&new&Thread(new&Runnable(){
&&&&&&&&&&&&@Override
&&&&&&&&&&&&public&void&run()&{
&&&&&&&&&&&&&&&&int&count&=&0;
&&&&&&&&&&&&&&&&while(count&&=&100){
&&&&&&&&&&&&&&&&&&&&if(flagA&==&4){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[0]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[0].write(&1&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagA&=&1;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagB&==&4){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[1]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[1].write(&1&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagB&=&1;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagC&==&4){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[2]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[2].write(&1&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagC&=&1;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagD&==&4){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[3]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[3].write(&1&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagD&=&1;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&cdl.countDown();
&&&&&&&&&&&&}
&&&&&&&&});
&&&&&&&&Thread&tB&=&new&Thread(new&Runnable(){
&&&&&&&&&&&&@Override
&&&&&&&&&&&&public&void&run()&{
&&&&&&&&&&&&&&&&int&count&=&0;
&&&&&&&&&&&&&&&&while(count&&=&100){
&&&&&&&&&&&&&&&&&&&&if(flagA&==&1){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[0]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[0].write(&2&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagA&=&2;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagB&==&1){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[1]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[1].write(&2&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagB&=&2;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagC&==&1){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[2]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[2].write(&2&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagC&=&2;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagD&==&1){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[3]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[3].write(&2&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagD&=&2;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&cdl.countDown();
&&&&&&&&&&&&}
&&&&&&&&});
&&&&&&&&Thread&tC&=&new&Thread(new&Runnable(){
&&&&&&&&&&&&@Override
&&&&&&&&&&&&public&void&run()&{
&&&&&&&&&&&&&&&&int&count&=&0;
&&&&&&&&&&&&&&&&while(count&&=&100){
&&&&&&&&&&&&&&&&&&&&if(flagA&==&2){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[0]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[0].write(&3&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagA&=&3;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagB&==&2){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[1]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[1].write(&3&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagB&=&3;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagC&==&2){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[2]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[2].write(&3&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagC&=&3;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagD&==&2){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[3]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[3].write(&3&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagD&=&3;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&cdl.countDown();
&&&&&&&&&&&&}
&&&&&&&&});
&&&&&&&&Thread&tD&=&new&Thread(new&Runnable(){
&&&&&&&&&&&&@Override
&&&&&&&&&&&&public&void&run()&{
&&&&&&&&&&&&&&&&int&count&=&0;
&&&&&&&&&&&&&&&&while(count&&=&100){
&&&&&&&&&&&&&&&&&&&&if(flagA&==&3){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[0]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[0].write(&4&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagA&=&4;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagB&==&3){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[1]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[1].write(&4&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagB&=&4;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagC&==&3){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[2]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[2].write(&4&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagC&=&4;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&if(flagD&==&3){
&&&&&&&&&&&&&&&&&&&&&&&&synchronized(fourFiles[3]){
&&&&&&&&&&&&&&&&&&&&&&&&&&&&fourFiles[3].write(&4&);
&&&&&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&&&&&flagD&=&4;
&&&&&&&&&&&&&&&&&&&&&&&&count++;
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&cdl.countDown();
&&&&&&&&&&&&}
&&&&&&&&});
&&&&&&&&tA.start();
&&&&&&&&tB.start();
&&&&&&&&tC.start();
&&&&&&&&tD.start();
&&&&public&static&void&main(String[]&args)&throws&InterruptedException{
&&&&&&&&FourThreadsWriteFourFiles&sxs&=&new&FourThreadsWriteFourFiles();
&&&&&&&&sxs.initThreads();
&&&&&&&&FourThreadsWriteFourFiles.cdl.await();
&&&&&&&&for(StringWriter&file&:&FourThreadsWriteFourFiles.fourFiles){
&&&&&&&&&&&&System.out.println(file);
俺深深地感觉到我就是个码农
第一个线程直接往A中写&......
第二个线程直接往B中写......
第三个线程直接往C中写......
第四个线程直接往D中写......
别跟我说没看清题意，我懒的思考...
这个领域完全不懂~看看~
第一个线程直接往A中写&......
第二个线程直接往B中写......
第三个线程直接往C中写......
第四个线程直接往D中写......
别跟我说没看清题意，我懒的思考...
你确实没看懂题意，每个线程都只能写一个特定的数字，第一个线程怎么写出1234四个数字
这四个线程根本不需要同步啊，各做各的互不影响啊
这四个线程根本不需要同步啊，各做各的互不影响啊
感觉你题目没有看仔细
我唯一能想到的就是&4个文件4把锁，另外还有一个闲置锁，初始时，1，2，3，4线程分别获得ABCD的锁，当一个线程写完自己的数字，按A-&空闲锁-&D-&C-&B-&A-&空闲锁的顺序获得下一个锁，然后释放自己的当前锁，让下一个线程来获取
有那么麻烦吗，不懂你们都在想什么（或许是我想错了，下面是我的想法）？
首先4个线程各自执行互不影响，但是每个线程在执行输出的时候是1-4，当大于4时重新设置成1。
4个线程的区别在于，第一个是从1开始，第二个是从2开始，第三个是从3开始，第四个是从4开始。
有那么麻烦吗，不懂你们都在想什么（或许是我想错了，下面是我的想法）？
首先4个线程各自执行互不影响，但是每个线程在执行输出的时候是1-4，当大于4时重新设置成1。
4个线程的区别在于，第一个是从1开始，第二个是从2开始，第三个是从3开始，第四个是从4开始。
每个线程只能写一个特定的数，线程1只能写1，不能写2，所以达不到你说的，从1开始的情况...
您的方法应该是可行的，非常感谢！
我唯一能想到的就是&4个文件4把锁，另外还有一个闲置锁，初始时，1，2，3，4线程分别获得ABCD的锁，当一个线程写完自己的数字，按A-&空闲锁-&D-&C-&B-&A-&空闲锁的顺序获得下一个锁，然后释放自己的当前锁，让下一个线程来获取
您的思想跟四楼的代码其实非常类似，你也可以看一下哈
每个线程写入文件的偏移位置是有规律、可计算的，所以每个线程直接偏移到指定位置写入即可，根本不需要锁。。。
这个对不对？
每个线程写入文件的偏移位置是有规律、可计算的，所以每个线程直接偏移到指定位置写入即可，根本不需要锁。。。
这个对不对？
建议编程尝试一下噢，
应该需要在代码中加上调度的逻辑
import&java.io.BufferedR
import&java.io.F
import&java.io.FileInputS
import&java.io.FileNotFoundE
import&java.io.FileOutputS
import&java.io.IOE
import&java.io.InputStreamR
import&java.io.OutputStreamW
import&java.util.A
import&java.util.concurrent.ExecutorS
import&java.util.concurrent.E
import&java.util.concurrent.atomic.AtomicI
import&java.util.concurrent.locks.ReentrantL
public&class&Main&{
static&ExecutorService&ex=Executors.newFixedThreadPool(4);
static&class&MyFile{
private&File&
//用来表示当前文件的索引
public&AtomicInteger&
private&ReentrantLock&lock=new&ReentrantLock();
public&MyFile(String&filePath,int&index){
file=new&File(filePath);
this.index=new&AtomicInteger(index);
//写入文件
public&void&writeStr(String&s)&throws&FileNotFoundException{
FileOutputStream&out=
OutputStreamWriter&cout=
lock.lockInterruptibly();
out=new&FileOutputStream(file,true);
cout=new&OutputStreamWriter(out);
cout.write(s);
}catch(InterruptedException&e){
e.printStackTrace();
}&catch&(IOException&e)&{
//&TODO&Auto-generated&catch&block
e.printStackTrace();
cout.close();
out.close();
}&catch&(IOException&e)&{
//&TODO&Auto-generated&catch&block
&&&&e.printStackTrace();
lock.unlock();
//读取文件
public&String&readStr(){
FileInputStream&in=
InputStreamReader&cin=
BufferedReader&br=
//System.out.println(&fawe&);
char[]&cbuf=new&char[100];
&in=new&FileInputStream(file);
&cin=new&InputStreamReader(in);
&br=new&BufferedReader(cin);
//br.readLine();
StringBuilder&sb=new&StringBuilder();
int&temp=0;
while((temp=br.read(cbuf))&0){
//System.out.println(&fawe&);
sb.append(new&String(cbuf),0,temp);
Arrays.fill(cbuf,'&');
return&sb.toString();
}&catch&(FileNotFoundException&e)&{
//&TODO&Auto-generated&catch&block
e.printStackTrace();
}&catch&(IOException&e)&{
//&TODO&Auto-generated&catch&block
e.printStackTrace();
in.close();
cin.close();
br.close();
}&catch&(IOException&e)&{
//&TODO&Auto-generated&catch&block
e.printStackTrace();
static&class&WriteThread&implements&Runnable{
private&int&
private&MyFile[]&
private&int&maxC
private&boolean&isFinished=
public&WriteThread(int&flag,MyFile[]&myfiles,int&maxChars){
this.flag=
this.myfiles=
this.maxChars=maxC
//@Override
public&void&run()&{
int&count=0;
while(count&=maxChars){
//System.out.println(count);
//遍历四个文件
for(int&i=0;i&myfiles.i++){
//System.out.println(i+&&&+myfiles[i].index.get());
if((myfiles[i].index.get()%4)==flag){
myfiles[i].writeStr(String.valueOf(flag+1));
//System.out.println(myfiles[i].index.get());
myfiles[i].index.incrementAndGet();
}&catch&(FileNotFoundException&e)&{
//&TODO&Auto-generated&catch&block
e.printStackTrace();
//线程已经写完
isFinished=
public&boolean&isFinished()&{
return&isF
static&class&ReadThread{
MyFile[]&myfiles=
public&ReadThread(MyFile[]&myfiles){
this.myfiles=
public&void&print(){
for(int&i=0;i&myfiles.i++){
System.out.println(myfiles[i].readStr());
public&static&void&main(String[]&args)&{
//建立文件
MyFile[]&myfiles=new&MyFile[4];
&&&&&&&&for(int&i=0;i&4;i++){
&&&&&&&& myfiles[i]=new&MyFile(&D://zt//java//MyEclipse&10//workspaceBoKe//多线程顺序打印//t&+(i+1)+&.txt&,&i);
&&&&&&&&WriteThread&t1=new&WriteThread(0,&myfiles,&20);
&&&&&&&&WriteThread&t2=new&WriteThread(1,&myfiles,&20);
&&&&&&&&WriteThread&t3=new&WriteThread(2,&myfiles,&20);
&&&&&&&&WriteThread&t4=new&WriteThread(3,&myfiles,&20);
&&&&&&&&ex.execute(t1);
&&&&&&&&ex.execute(t2);
&&&&&&&&ex.execute(t3);
&&&&&&&&ex.execute(t4);
&&&&&&&while(true){
&&&&&&&& //System.out.println(&wait&);
&&&&&&&& if(t1.isFinished()&&t2.isFinished()&&t3.isFinished()&&t4.isFinished()){
ex.shutdown();
//读取文件
new&ReadThread(myfiles).print();
&&&&&&&& }
运行结果：
我唯一能想到的就是&4个文件4把锁，另外还有一个闲置锁，初始时，1，2，3，4线程分别获得ABCD的锁，当一个线程写完自己的数字，按A-&空闲锁-&D-&C-&B-&A-&空闲锁的顺序获得下一个锁，然后释放自己的当前锁，让下一个线程来获取
我觉得根本用不着锁，题目没有指明文件只能一次性写入，既然这样，那么写了一次后就把文件关闭，用一个数组记录每个线程的写入状态，分析按照逻辑，4个线程分别把对应的1、2、3、4、写入完成后再写下一行的2、3、4、1，依次往下。
为了实现，没做其他的什么判断，简单的生产消费思想，Queue&和&模拟文件的LIst&还有&线程&完成可以通过数组来简化代码
public&class&ThreadTest&{
&&&&public&static&void&main(String[]&args)&throws&InterruptedException&{
&&&&&&&&BlockingQueue&List&Integer&&&a&=&new&ArrayBlockingQueue&List&Integer&&(2);
&&&&&&&&BlockingQueue&List&Integer&&&b&=&new&ArrayBlockingQueue&List&Integer&&(2);
&&&&&&&&BlockingQueue&List&Integer&&&c&=&new&ArrayBlockingQueue&List&Integer&&(2);
&&&&&&&&BlockingQueue&List&Integer&&&d&=&new&ArrayBlockingQueue&List&Integer&&(2);
&&&&&&&&List&Integer&&fileA&=&new&ArrayList&&();
&&&&&&&&List&Integer&&fileB&=&new&ArrayList&&();
&&&&&&&&List&Integer&&fileC&=&new&ArrayList&&();
&&&&&&&&List&Integer&&fileD&=&new&ArrayList&&();
&&&&&&&&a.put(fileA);
&&&&&&&&b.put(fileB);
&&&&&&&&c.put(fileC);
&&&&&&&&d.put(fileD);
&&&&&&&&WriteNum&aT=new&WriteNum(a,&b,&1);
&&&&&&&&WriteNum&bT=new&WriteNum(b,&c,&2);
&&&&&&&&WriteNum&cT=new&WriteNum(c,&d,&3);
&&&&&&&&WriteNum&dT=new&WriteNum(d,&a,&4);
&&&&&&&&aT.start();
&&&&&&&&bT.start();
&&&&&&&&cT.start();
&&&&&&&&dT.start();
&&&&&&&&while(aT.isAlive()||&bT.isAlive()||&cT.isAlive()||&dT.isAlive()){
&&&&&&&&&&&&System.out.println(&Running&);
&&&&&&&&System.out.println(&FILEA:&);
&&&&&&&&for(int&i&:&fileA){
&&&&&&&&&&&&System.out.print(i);
&&&&&&&&System.out.println();
&&&&&&&&System.out.println(&FILEB:&);
&&&&&&&&for(int&i&:&fileB){
&&&&&&&&&&&&System.out.print(i);
&&&&&&&&System.out.println();
&&&&&&&&System.out.println(&FILEC:&);
&&&&&&&&for(int&i&:&fileC){
&&&&&&&&&&&&System.out.print(i);
&&&&&&&&System.out.println();
&&&&&&&&System.out.println(&FILED:&);
&&&&&&&&for(int&i&:&fileD){
&&&&&&&&&&&&System.out.print(i);
&&&&static&class&WriteNum&extends&Thread&{
&&&&&&&&BlockingQueue&List&Integer&&&currQ
&&&&&&&&BlockingQueue&List&Integer&&&nextQ
&&&&&&&&int&
&&&&&&&&public&WriteNum(BlockingQueue&List&Integer&&&currQueue,&BlockingQueue&List&Integer&&&nextQueue,&int&num)&{
&&&&&&&&&&&&this.currQueue&=&currQ
&&&&&&&&&&&&this.nextQueue&=&nextQ
&&&&&&&&&&&&this.num&=&
&&&&&&&&@Override
&&&&&&&&public&void&run()&{
&&&&&&&&&&&&super.run();
&&&&&&&&&&&&for&(int&i&=&0;&i&&&20;&i++)&{
&&&&&&&&&&&&&&&&try&{
&&&&&&&&&&&&&&&&&&&&List&Integer&&file&=&currQueue.take();
&&&&&&&&&&&&&&&&&&&&file.add(num);
&&&&&&&&&&&&&&&&&&&&nextQueue.put(file);
&&&&&&&&&&&&&&&&}&catch&(InterruptedException&e)&{
&&&&&&&&&&&&&&&&&&&&e.printStackTrace();
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&}
将文件&打开，用随机读写模式。先确定一下文件大小，然后开始搞
线程1写i*4+0的位置。
线程2写i*4+1
线程3写i*4+2
线程4写i*4+3
妥妥的，啥线程锁都没有了。
应该要用信号量（Semaphore）吧
方法一，轮训模式：
&&&&&&爆简单，首先决定被写入的文件是否可以上锁，每个现场在文件没有被锁住的情况下，读取最后一个数字，判断是不是可以写入自己该写入的文字，如果不是按照同样规则则处理下一个文件，如果都没有则等待一个时间间隔等待其他线程来处理，
方法二：消息模式：
&&&&首先创建线程t1，处理完成文件A，t1结束时送出消息，主线程收到消息后创建线程t2,处理文件A，t1结束时送出消息创建t3，一次类推。要同时处理A、B/C/D四个文件，则创建四组这样的对象即可
还有个方法三：用&WaitforsingleObject&函数，这个比较复杂就不描述了。
四个线程，每个线程一个任务队列，例如编号A,B,C,D。初始时线程A持有文件1的句柄，B持有文件2的句柄，C持有文件3的句柄，D持有文件4的句柄，每个线程向任务队列中的句柄写入数据后就将该文件句柄放入（n+1）%4&+&1的线程队列中，完事。。。
没等考虑线程同步呢,跑了几遍没啥问题.......
package&forFourFileTest1;
import&java.io.*;
import&java.util.ArrayL
&*&建立四个文件&br&
&*&建立四个线程,每个线程分别输出1,2,3,4到文件内部&&br&
&*&文件要求效果&&br&
&*&A:.....&br&
&*&B:....&&br&
&*&C:....&&br&
&*&D:....&br&
public&class&Test&{
/**建立四个文件,分别对应着一个IOStreamWriter及一个标志char&flag标示着下一个等待输入的字符*/
private&static&Files&
public&static&void&main(String[]&args)&throws&IOException&{
files&=&new&Files();
Thread&th1&=&new&Thread(new&Th(files,&'1'));
th1.start();
Thread&th2&=&new&Thread(new&Th(files,&'2'));
th2.start();
Thread&th3&=&new&Thread(new&Th(files,&'3'));
th3.start();
Thread&th4&=&new&Thread(new&Th(files,&'4'));
th4.start();
&*&单个文件对应一个OutputStreamWriter&及一个char&flag标示等待输入的下一个字符
class&SFile&{
private&OutputStreamWriter&
public&OutputStreamWriter&getFr()&{
public&void&setFr(OutputStreamWriter&fr)&{
this.fr&=&
public&char&getFlag()&{
public&void&setFlag(char&flag)&{
this.flag&=&
private&char&
//更新等待输入的字符
public&void&updateFlag()&{
if&(flag&==&'4')
flag&=&'1';
else&if&(flag&==&'1')
flag&=&'2';
else&if&(flag&==&'2')
flag&=&'3';
else&if&(flag&==&'3')
flag&=&'4';
System.out.println(&flag&error&);
public&SFile(String&name,&char&flag)&throws&IOException&{
this.fr&=&new&FileWriter(new&File(&/home/wjx/workspace/&&+&name));
this.flag&=&
&*&将四个文件的带flag的Writer放进一个ArrayList*/
class&Files&{
private&ArrayList&SFile&&
public&ArrayList&SFile&&getFiles()&{
Files()&throws&IOException&{
files&=&new&ArrayList&&();
files.add(new&SFile(&file1&,&'1'));
files.add(new&SFile(&file2&,&'2'));
files.add(new&SFile(&file3&,&'3'));
files.add(new&SFile(&file4&,&'4'));
class&Th&implements&Runnable&{
char&c;//线程负责写入的字符
ArrayList&SFile&&//指向被写入的四个文件带flag的Writer的ArrayList
public&Th(Files&files,&char&c)&{
this.files&=&files.getFiles();
this.c&=&c;
public&void&run()&{
while&(true)&{
for&(SFile&g&:&files)&{
if&(g.getFlag()&==&this.c)&{
g.getFr().append(this.c);
g.getFr().flush();
}&catch&(IOException&e)&{
e.printStackTrace();
g.updateFlag();
这道题目主要是考虑程序员对性能的理解，实现方法很多，但要注意算法，我觉得求模处理这个问题最合适不过了。
定义一个变量存放模的范围，你这里最大数是4，那么模就是4.
线程1,2,3,4分别对应一个文件，每个线程独立对应一个文件，这样减少了判断，增强了执行效率。
每个线程在执行一次就自增1再求模，可以如下理解：
线程1，&执行是&0%4&=&0&&&，&&1%4=1，&2%4=2&，3%4=&3&，&结果0123&不是我们要取的值，所以结果必须都+1变成1234.所以&0%4&=&0&&+1&&，&&1%4=1&+1，&2%4=2&+1，3%4=&3&+1&.&&4&%4&=0+1&,&5%4=1+1,可以一直循环下去
线程234跟线程1同理，只是它们的初始值分别变成&&1，2，3。
这样的好处是性能最大化。互相不干扰，也不会出错。
补充下，由于已经给出了每个线程的初值&&1&，2&，3&，4&&&所以&上诉不用考虑初值，只要递增就好了。
哇塞，楼主貌似都结贴了，大家还在回复呀，
obj.wait(),notify(),每个线程来一个锁，应该就实现了
将文件&打开，用随机读写模式。先确定一下文件大小，然后开始搞
线程1写i*4+0的位置。
线程2写i*4+1
线程3写i*4+2
线程4写i*4+3
妥妥的，啥线程锁都没有了。
talk&is&cheap,show&me&the&code
这道题目主要是考虑程序员对性能的理解，实现方法很多，但要注意算法，我觉得求模处理这个问题最合适不过了。
定义一个变量存放模的范围，你这里最大数是4，那么模就是4.
线程1,2,3,4分别对应一个文件，每个线程独立对应一个文件，这样减少了判断，增强了执行效率。
每个线程在执行一次就自增1再求模，可以如下理解：
线程1，&执行是&0%4&=&0&&&，&&1%4=1，&2%4=2&，3%4=&3&，&结果0123&不是我们要取的值，所以结果必须都+1变成1234.所以&0%4&=&0&&+1&&，&&1%4=1&+1，&2%4=2&+1，3%4=&3&+1&.&&4&%4&=0+1&,&5%4=1+1,可以一直循环下去
线程234跟线程1同理，只是它们的初始值分别变成&&1，2，3。
这样的好处是性能最大化。互相不干扰，也不会出错。
若能给出实现代码就更好了
把数字做成临界资源&并加锁就可以了。java我不了解。
c#大概如下
private&int&GetNumber(){
&&&&&&&&&&&&&&lock(ob){
if(num&4)&num=1;
开4个线程调这个方法。
这只能是题，现实中不可能这样子做。