java多线程问题，求大神解答

[fox2253212]

有一个学生对象，包含学号、姓名、班级属性
生成10个学生对象后放入集合中
运用多线程读取集合中学生对象后将学生信息写入到同一文件（按学生学号排序）

本人多线程实在不会，求大神解答。（不实现排序的也行）主要是能有多线程方面的代码提供下参考

[S117]

用队列把，典型的生产者和消费者模式

[fox2253212]

能否代码实现下，多线程方面真心不太会

[qingyuan18]

你的学生对象实现comparable接口没？实现了的话直接用Arrays.Sort排好序，写文件非要用线程的话，那也就是注意文件锁，即同一时间只能一个线程在写结果文件 comparable接口的compare方法里面用学生序号做比较 线程用匿名内部类即可： Thread thread = new Thread( new Runable() { public void run() { //写文件操作，注意加sychnorized(文件实例)锁以避免多个线程同时写文件 } });

[a12939026]

没啥特别的啊。 你单线程会的罗，多线程就是注意锁就行了 随便写的,没用IDE。 可能有小问题。 public class Test extends Thread { Student student; public Test(Student s) { this.student = student; } public void run(){ writeStudent() } public void writeStudent() { sychronized(this.class){ //将student写入文件 } } public static void main(String args){ new Test(new Student()).start(); new Test(new Student()).start(); new Test(new Student()).start(); } }

[业余草]

java有线程池，你直接维护，即可！！！

[鱿鱼x]

符合要求了，希望认真看看

public class Client {

	private final static int N_THREADS = 4;

	public static void main(String[] args) throws InterruptedException {

		final Queue<Student> quque = new LinkedList<Student>();
		for (int i = 0; i < 20; i++) {
			quque.add(new Student(i, "student" + i));// 初始化...形式可变
		}
		final StringBuffer sb = new StringBuffer();

		final CountDownLatch startGate = new CountDownLatch(1);
		final CountDownLatch endGate = new CountDownLatch(N_THREADS);

		for (int i = 0; i < N_THREADS; i++) {
			new Thread() {
				public void run() {
					try {
						startGate.await();
						while (true) {
							synchronized (quque) {

								if (!quque.isEmpty())
									sb.append(quque.poll() + "\n");
								else
									break;
							}
						}

					} catch (InterruptedException e) {
						e.printStackTrace();
					} finally {
						endGate.countDown();
					}
				};
			}.start();
		}

		startGate.countDown();
		endGate.await();
		System.out.println(sb.toString());// 把字符串 IO写入即可

	}
}

class Student {

	private final int id;
	private final String name;

	public Student(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public int getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}

}

[rmn190]

参考这个：

import java.util.*;
import java.io.*;
import java.util.concurrent.*;

/** Producer-Consumer in Java, for J2SE 1.5 using concurrent.
 */
public class ProdCons15 {

  protected boolean done = false;

  /** Inner class representing the Producer side */
  class Producer implements Runnable {

    protected BlockingQueue queue;

    Producer(BlockingQueue theQueue) { this.queue = theQueue; }

    public void run() {
      try {
        while (true) {
          Object justProduced = getRequestFromNetwork();
          queue.put(justProduced);
          System.out.println("Produced 1 object; List size now " + queue.size());
          if (done) {
            return;
          }
        }
      } catch (InterruptedException ex) {
        System.out.println("Producer INTERRUPTED");
      }
    }

    Object getRequestFromNetwork() {  // Simulation of reading from client
      try {
          Thread.sleep(10); // simulate time passing during read
      } catch (InterruptedException ex) {
         System.out.println("Producer Read INTERRUPTED");
      }
      return(new Object());
    }
  }

  /** Inner class representing the Consumer side */
  class Consumer implements Runnable {
    protected BlockingQueue queue;

    Consumer(BlockingQueue theQueue) { this.queue = theQueue; }

    public void run() {
      try {
        while (true) {
          Object obj = queue.take();
          int len = queue.size();
          System.out.println("List size now " + len);
          process(obj);
          if (done) {
            return;
          }
        }
      } catch (InterruptedException ex) {
          System.out.println("CONSUMER INTERRUPTED");
      }
    }

    void process(Object obj) {
      // Thread.sleep(xxx) // Simulate time passing
      System.out.println("Consuming object " + obj);
    }
  }

  ProdCons15(int nP, int nC) {
    BlockingQueue myQueue = new LinkedBlockingQueue();
    for (int i=0; i<nP; i++)
      new Thread(new Producer(myQueue)).start();
    for (int i=0; i<nC; i++)
      new Thread(new Consumer(myQueue)).start();
  }

  public static void main(String[] args)
  throws IOException, InterruptedException {

    // Start producers and consumers
    int numProducers = 4;
    int numConsumers = 3;
    ProdCons15 pc = new ProdCons15(numProducers, numConsumers);

    // Let the simulation run for, say, 10 seconds
    Thread.sleep(10*1000); 

    // End of simulation - shut down gracefully
    pc.done = true;
  }
}