答复: 迅雷亲历面经：JAVA 笔试+上机+面试（完整面试题大讨论）

引用

有三个线程ID分别是A、B、C,请有多线编程实现，在屏幕上循环打印10次ABCABC…

引申了一下：

有n个线程，ID为0...n-1，在屏幕上循环打印m次012..n-1

用 c/pthread 实现

//@Author      : [e-mail]
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>

#define GROUP_COUNT 100
#define GROUP_SIZE 4 

typedef struct {
	pthread_mutex_t mutex;
	pthread_cond_t cond;
	int index;
} syn_obj_t;

syn_obj_t syn_obj = {PTHREAD_MUTEX_INITIALIZER, 
	PTHREAD_COND_INITIALIZER, 0};

typedef struct {
	int flag;
} elem_t; 

void *
thread_routine(void *arg);

int
main(int argc, char** argv)
{
	elem_t elems[GROUP_SIZE];
	pthread_t pds[GROUP_SIZE];
	int i;

	printf("syn_obj.index = %d\n", syn_obj.index);

	for (i = 0; i < GROUP_SIZE; i++) {
		elems[i].flag = i;
		if ( (pthread_create(&pds[i], NULL, thread_routine, &elems[i])) != 0 ) {
			perror("pthread create");
			exit(-1);
		}
	}

	for (i = 0; i < GROUP_SIZE; i++) {
		pthread_join(pds[i], NULL);
	}

	pthread_mutex_destroy(&syn_obj.mutex);
	pthread_cond_destroy(&syn_obj.cond);

	printf("\nsyn_obj.index = %d\n", syn_obj.index);

	return 0;
}

void *
thread_routine(void *arg) {
	elem_t *elem = (elem_t *)arg;
	int i;
	for (i = 0; i < GROUP_COUNT; i++) {
		pthread_mutex_lock(&syn_obj.mutex);
		while ( (syn_obj.index % GROUP_SIZE) != elem->flag ) {
			pthread_cond_wait(&syn_obj.cond, &syn_obj.mutex);
	 	}
		printf("%d", elem->flag);
		if ( 0 == (syn_obj.index+1) % GROUP_SIZE ) {
			printf("\t");
		}
		syn_obj.index++;
		pthread_cond_broadcast(&syn_obj.cond);
		// may be cause deadlock 
		// pthread_cond_signal(&syn_obj.cond);
		pthread_mutex_unlock(&syn_obj.mutex);
		// sleep(1);
	}
	return NULL;
}

评论

26 楼 panshunchang 2010-06-03  

public class TestThread {

static Boolean[] str = new Boolean[]{true,false,false};

public static void main(String[] args) throws InterruptedException {
Thread1 t1 = new Thread1();
Thread2 t2 = new Thread2();
Thread3 t3 = new Thread3();
t1.start();
// //t1.join();
t2.start();
// //t2.join();
t3.start();
//t3.join();
}



static class Thread1 extends Thread{
public void run(){
int i=10;
while(i>0){
synchronized (str) {
if(str[0]){
System.out.print("A");
i--;
str[0] =false ;
str[1] = true;
str.notifyAll();
}else{
try {
str.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

static class Thread2 extends Thread{
public void run(){
int i=10;
while(i>0){
synchronized (str) {
if(str[1]){
System.out.print("B");
i--;
str[1] = false ;
str[2] = true;
str.notifyAll();
}else{
try {
str.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}


static class Thread3 extends Thread{

public void run(){
int i=10;
while(i>0){
synchronized (str) {
if(str[2]){
System.out.print("C");
i--;
str[2] = false;
str[0] = true;
str.notifyAll();
}else{
try {
str.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

}

25 楼 iceman1952 2010-04-24  

不输出ABC啦，就输出A0A1A2....

package xunlei;

import java.util.ArrayList;

class CtrlStruct {
	private Object objLock = new Object();
	private int threadCount;
	private int loopCount;
	private int hasRunTimes;

	public int getThreadCount() {
		return threadCount;
	}

	public void setThreadCount(int threadCount) {
		this.threadCount = threadCount;
	}

	public int getLoopCount() {
		return loopCount;
	}

	public void setLoopCount(int loopCount) {
		this.loopCount = loopCount;
	}

	public Object getObjLock() {
		return objLock;
	}

	public int getHasRunTimes() {
		return hasRunTimes;
	}

	public void setHasRunTimes(int threadCount) {
		this.hasRunTimes = threadCount;
	}

}

class OutputName extends Thread {
	private int index;
	private CtrlStruct tt;

	public OutputName(int index, CtrlStruct tt) {
		super("A" + index);
		this.index = index;
		this.tt = tt;
	}

	public void run() {
		int count = 0;
		synchronized (tt.getObjLock()) {
			while (count < tt.getLoopCount()) {
				// 不该打印自己，则等待
				while (index != tt.getHasRunTimes() % tt.getThreadCount()) {
					try {
						tt.getObjLock().wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				count++;
				tt.setHasRunTimes((tt.getHasRunTimes()) + 1);
				System.out.print(Thread.currentThread().getName());
				tt.getObjLock().notifyAll();
			}
		}

	}

}

public class Test {
	public static void main(String[] args) {
		int threadCount = 3;
		int loopCount = 10;
		ArrayList list = new ArrayList();
		CtrlStruct cs = new CtrlStruct();
		for (int i = 0; i < threadCount; i++) {
			OutputName opn = new OutputName(i, cs);
			list.add(opn);
		}
		cs.setLoopCount(loopCount);
		cs.setThreadCount(threadCount);
		cs.setHasRunTimes(0);
		for (int i = 0; i < list.size(); i++) {
			((Thread) list.get(i)).start();
		}
	}
}

24 楼 黑山老妖 2010-03-03  

public class ThreadPrintABC {
	public static void main(String args[]) {
		Print p = new Print();
		new PrintThread(p);
		new PrintThread(p);
		new PrintThread(p);
	}
}
/**
 * 打印类，打印类负责打印的内容。
 * @author 
 *
 */
class Print {
	String word = "A";
	void print() {		
		System.out.print(word);
		if (word.equals("A")) {
			word = "B";
		} else if (word.equals("B")) {
			word = "C";
		} else if (word.equals("C")) {
			word = "A";
		}

	}
}
/**
 * 打印线程，只负责调用打印类。不负责打印内容。
 * @author
 *
 */
class PrintThread implements Runnable {
	Print p;
	Thread t;

	PrintThread(Print p) {
		this.p = p;
		t = new Thread(this);
		t.start();
	}

	public void run() {
		int j = 10;
		while (j > 0) {
			synchronized (p) {//同步 重要 不然打印顺序会乱
				p.print();
				j--;
			}			
		}
	}

}

23 楼 laoshifu 2010-03-01  

swen00 写道

闲来也写个，我这不用同步实现..
public class TestThread {
    static int num = 1;

    public static void main(String ds[]){
        new DemoThread(1,"A").start();
        new DemoThread(2,"B").start();
        new DemoThread(0,"C").start();
    }

    static class DemoThread extends Thread {
        int id;
        String pintln_str;
       
        public DemoThread(int id,String pintln_str) {
            this.id = id;
            this.pintln_str = pintln_str;
        }

        int print_num = 10;

        public void run() {           
            while (print_num > 0) {
                if (num%3 == id) {
                    System.out.print(pintln_str);
                    num ++ ;
                    print_num--;
                }
            }
        }
    }
}

浏览了所有回帖，发现这个是最精炼的。

22 楼 zhuyx808 2009-12-16  

其实我有个恶心的解法：

公用方法D｛
System.out.println("abc");
｝

线程A｛
公用方法D
｝
线程B｛
公用方法D
｝
线程C｛
公用方法D
｝

21 楼 shadao 2009-12-15  

@Test
    public void helloThreads() throws InterruptedException {

        final int threads = 9;
        final int times = 6;

        ExecutorService service = Executors.newFixedThreadPool(threads);
        final Lock lock = new ReentrantLock();

        final Condition[] conditions = new Condition[threads];
        for (int i = 0; i < conditions.length; i++) {
            conditions[i] = lock.newCondition();
        }

        Runnable[] runs = new Runnable[threads];
        for (int i = 0; i < runs.length; i++) {
            runs[i] = new Runer(i) {

                @Override
                public void run() {
                    int t = times;
                    while (t-- > 0) {
                        lock.lock();
                        try {
                            conditions[index].await();
                            //work
                            System.out.print(Thread.currentThread().getName());
                            System.out.print(" ");
                            
                            int nextIndex = index+1;
                            if(nextIndex==threads){
                                nextIndex = 0;
                                //for beautiful
                                System.out.println();
                            }
                            
                            //give a signal to next thread
                            conditions[nextIndex].signalAll();
                        } catch(Exception ex){
                            ex.printStackTrace();
                        } finally {
                            lock.unlock();
                        }
                    }
                }
            };
        }

        for(Runnable r:runs){
            service.execute(r);
        }

        //first one
        lock.lock();
        conditions[0].signalAll();
        lock.unlock();

        //hold on
        Thread.sleep(Long.MAX_VALUE);
    }

    abstract class Runer implements Runnable{
        protected final int index;
        
        public Runer(int index){
            this.index = index;
        }

    }

20 楼 fy_kenny 2009-12-15  

有没有线程间通信的机制？

现成的类有吗？

比方说ThreadGroup可以利用吗

19 楼 lj830723 2009-12-12  

线程方面不太熟悉，正在学习中，借鉴楼上的了各种方法了

18 楼 gq913 2009-12-11  

java synchronized方法就搞定了 有那么麻烦吗？

17 楼 swen00 2009-12-11  

闲来也写个，我这不用同步实现..
public class TestThread {
    static int num = 1;

    public static void main(String ds[]){
        new DemoThread(1,"A").start();
        new DemoThread(2,"B").start();
        new DemoThread(0,"C").start();
    }

    static class DemoThread extends Thread {
        int id;
        String pintln_str;
       
        public DemoThread(int id,String pintln_str) {
            this.id = id;
            this.pintln_str = pintln_str;
        }

        int print_num = 10;

        public void run() {           
            while (print_num > 0) {
                if (num%3 == id) {
                    System.out.print(pintln_str);
                    num ++ ;
                    print_num--;
                }
            }
        }
    }
}

16 楼 chenyongan 2009-12-11  

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class TestThread {

/**
* @param args
*/
public static void main(String[] args) {
MyThread b = null;
MyThread c = null;
MyThread a = null;
Status status = new Status();
a = new MyThread("A", 0, status);
b = new MyThread("B", 1, status);
c = new MyThread("C", 2, status);
b.start();
c.start();
a.start();
}
}

class Status {
private int all = 30;

private int i = 0;
private boolean isOver=false;

public boolean isOver() {
return isOver ;
}

public synchronized void next() {
if(all-1>i){
i++;
}else{
isOver=true;
}
}
public int getStatus(){
return i%3;
}
}

class MyThread extends Thread {
public int status;
public Status s;
public MyThread(String name, int status, Status s) {
super(name);
this.status = status;
this.s = s;
}

public void run() {
while (!s.isOver()) {
if (s.getStatus()== status) {
System.out.print(this.getName());
s.next();
}
}
}
}

15 楼 wandou 2009-12-10  

interface IWakeAble{
    void wakeMe();
    void addSleepListener(ISleepListener listener);
}
interface ISleepListener{
    void beforeSleep(Object sender);
}
ThreadA,b,c 实现 IWakeAble;然后用一个ThreadManager去监听beforeSleep事件，一个完成了就wake下一个。

14 楼 dengmingfeng 2009-12-09  

好像是深圳的面试题，

13 楼 huohu0321 2009-12-07  

java中用Executors.newSingleThreadExecutor()，执行线程行不。

12 楼 qeppykqsn 2009-12-07  

楼主，这可是人家的机密。。。你。。。你。。。你。。。

11 楼 trydofor 2009-12-07  

来个好玩的

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class TBThread {
	public static void main(String[] args) {
		List<String>  work = new ArrayList<String>(Arrays.asList("123456789".split("")));
		work.removeAll(Collections.singletonList(""));
		final List<String> task = new ArrayList<String>(work);
		Collections.shuffle(work);
		System.out.print("work:");
		for(String s :work)System.out.print(","+s);
		System.out.print("\ntask:");
		for(String s :task)System.out.print(","+s);
		System.out.print("\nexec:");
		
		for(final String s :work){
			new Thread(){
				public void run() {
					try {
						sleep(new Random().nextInt(5000));
						synchronized (task) {
							if(task.isEmpty()) return;
							while(!s.equals(task.get(0))) task.wait();
							System.out.print(","+task.remove(0));
							task.notifyAll();
						}
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}.start();
		}
	}
}

10 楼 sun_cyj 2009-12-06  

package com.test;

public class Test {
	public static void main(String[] args) {
		ThreadRun A = new ThreadRun();
		ThreadRun B = new ThreadRun();
		ThreadRun C = new ThreadRun();
		A.setName("A");
		A.setCanRun(true);
		A.setNextRun(B);
		B.setName("B");
		B.setNextRun(C);
		C.setName("C");
		C.setNextRun(A);
		A.start();
		B.start();
		C.start();
	}
}
class ThreadRun extends Thread
{
	//private static int runTime = 1;
	private ThreadRun nextRun;
	
	
	private boolean canRun;
	
	
	
	public ThreadRun getNextRun() {
		return nextRun;
	}



	public void setNextRun(ThreadRun nextRun) {
		this.nextRun = nextRun;
	}



	


	public boolean isCanRun() {
		return canRun;
	}



	public void setCanRun(boolean canRun) {
		this.canRun = canRun;
	}



	public void run() {
		for (int i = 0; i < 10; ) {
			if(this.canRun)
			{
				System.out.println(this.getName());
				nextRun.setCanRun(true);
				this.setCanRun(false);
				i++;
				
			} else
				try {
					this.sleep(1);
				} catch (InterruptedException e) {
					
					e.printStackTrace();
				}
		}
		
		
	}
}

9 楼 wave-labs 2009-12-06  

一种没有使用并发包的实现。遇到一个问题，lock对象如果直接用Integer会异常，封装成Lock类就可以了。

public class SequenceTask {

	private static volatile Lock lock = new Lock();

	private static String[] infos = { "A", "B", "C" };

	public static void main(String[] args) {
		for (int i = 0; i < infos.length; i++) {
			Thread thread = new Thread(new PrintTask(i));
			thread.start();
		}
	}

	static class Lock {
		private int flag = 0;

		public int getFlag() {
			return flag;
		}

		public void setFlag(int flag) {
			this.flag = flag;
		}
	}

	static class PrintTask implements Runnable {
		private int id;

		public PrintTask(int id) {
			this.id = id;
		}

		public void run() {
			while (true) {
				synchronized (lock) {
					if (lock.getFlag() == id) {
						System.out.print(infos[id]);
						lock.setFlag((id + 1) % infos.length);
						lock.notifyAll();
					} else {
						try {
							lock.wait();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

8 楼 flyingpig4 2009-12-06  

我参照了下兄弟们写的，用的是JAVA5.0的ReentrantLock也写了一个：
大家一起一为鉴赏一下
调用类：FuLockThreadTest //用于线程ABC的调用实现
public class FuLockThreadTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// 加锁实现
new Thread(new FuLockThread(0), "A").start();// 注意线程命名
new Thread(new FuLockThread(1), "B").start();
new Thread(new FuLockThread(2), "C").start();
}
}
线程类：FuLockThread //用ReentrantLock加锁机制实现，注意在finally里面实现解锁
import java.io.IOException;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class FuLockThread extends Thread {

private int id;
private static int count = 0;// 活学活用static类型
private int pcount;
private boolean mark = true;
private ReentrantLock lock;
private Condition condition;

public FuLockThread(int id) {
this.id = id;
lock = new ReentrantLock();
condition = lock.newCondition();
}

@Override
public void run() {
// TODO Auto-generated method stub
// 当前的count计数为id值，则进行输出
// 加锁实现

lock.lock();
try {// 加锁实现
while (mark) {
if (count % 3 == id) {
System.out.print(Thread.currentThread().getName());
count++;
pcount++;
condition.signalAll();
if (pcount == 10)
mark = false;
}
}
} finally {
if (count % 3 != id) {
try {
condition.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else
lock.unlock();
}
}
}

7 楼 shelocks 2009-12-06  

sunzixun 写道

easonfans 写道

shelocks 写道

   贴一个Java的，实现可能和楼主的有些差别，输出A、B、C分别使用三个不同的线程类。不过原理都是一样，实现线程的顺序调度。判断条件，不满足的话，等待；接到通知以后，重新判断。

public class SequenceWork {

    private static Boolean[] abc = {false, false, true};

    public static void main(String[] args) {
        ThreadA a = new ThreadA();
        a.start();
        ThreadB b = new ThreadB();
        b.start();
        ThreadC c = new ThreadC();
        c.start();
    }

    static class ThreadA extends Thread {

        public void run() {
            while (true) {
                synchronized (abc) {
                    if (abc[2]) {
                        System.out.print("A");
                        abc[0] = true;
                        abc[2] = false;
                        abc.notifyAll();
                    } else {
                        try {
                            abc.wait();
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                    }

                }
            }

        }
    }
//。。。。。。。。。。。。。

楼上的解法正点！

万一是线程池呢。。。。。。你的代码就吓死人了哈哈

  输出A、B、C是三个不同的任务，他们之间要以一种顺序化的顺序调度，而不是简单的在一个线程里输出不同的标志位。上面的示例代码代码是extends thread，你完全可以把它实现为Runnable。跟线程池有什么关系。