继续：关于线程的问题 还是有点想不明白

Question

上次的这个问题，假如我现在有10条数据，每次向容器中放入2条，这个放的操作每次的时间间隔是60毫秒，这个操作该怎么用线程来表示呢？？？

假如我每次放入dest两个之后，那要怎么把放入的两个再删除掉呢？？？不会操作了。

因为要进行一个传递的操作，每次传递2个，把放入dest的那两个传递了。第二次的时候，就是要把之前 的两个删掉，再放入两个，传递。是这样的一个过程，这个删除要在哪里写最合适呢？？？不懂( ⊙o⊙ )哇

package net.oschina.tester;

import java.util.*;

public class Test {

	public static void main(String[] args) {
		final List<Integer> src = new ArrayList<Integer>(){{//源容器
			for(int i=1;i<=10;i++)
				add(i);
		}};
		final List<Integer> dest = new ArrayList<Integer>();//目标容器
		
		new Thread(){
			int count_once = 2;//每次放2个元素
			int pos = 0;
			@Override
			public void run() {
				while(true){
					for(int i=0;i<count_once && pos<src.size();i++){
						dest.add(src.get(pos++));
					}
					//间隔时间60毫秒
					try {
						Thread.sleep(60);
					} catch (InterruptedException e) {
						break;
					}
					System.out.printf("pos=%dn",pos);
					if(pos >= src.size())
						break;
				}
			}
			
		}.start();
	}
	
}

Answer 1

对,是我失误

Answer 2

你把 long start = System.currentTimeMillis();放在for循环之前就不会莫名其妙了。

Answer 3

感觉这东西和线程是没有关系的啊?你要是多线程的话,应该对共享资源src进行加锁的吧

Answer 4

了解 了解

Answer 5

原来如此

Answer 6

栈是先进后出的，这种是模拟队列，先进先出。本来也应该是用队列来做的。

Answer 7

多线程测试,虽然多线程时,的确耗时少了,可是当线程过多时,比如1000,感觉有点儿莫名其秒?

public class Test2 implements Runnable {
	public long total_times = 0;

	final List<Integer> src = new ArrayList<Integer>() {
		private static final long serialVersionUID = 6003275546949774361L;
		{// 源容器
			for (int i = 1; i <= 100000; i++)
				add(i);
		}
	};
	final List<Integer> dest = new ArrayList<Integer>();// 目标容器

	public void run() {
		while (true) {
			if (src.size() == 0)
				break;
			for (int j = 0; j < 2; j++) {
				synchronized (src) {
					if (src.size() > 0) {
						dest.add(src.get(0));
						src.remove(0);
					} else {
						break;
					}
				}
			}
			// 间隔时间60毫秒
			try {
				Thread.sleep(0); // 可以调节此参数试试
			} catch (InterruptedException e) {
				break;
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		Test2 test = new Test2();
		
		// 线程数,可以调节测试10-100-500?
		int thread_count = 10;
		
		for (int i = 0; i < thread_count; i++) {
			new Thread(test, "t" + i).start();
		}

		long start = System.currentTimeMillis();
		while (true) {
			if (test.src.size() == 0) {
				break;
			}
		}
		long end = System.currentTimeMillis();
		System.out.println("所有线程累计执行时间:" + (end-start));
	}
}

Answer 8

还是有一些小问题的，是在用多线程了。。。这里是用了单线程，还有其他的地方是用了多线程。O(∩_∩)O哈哈~有不会的继续问~(≧▽≦)/~啦啦啦

Answer 9

		new Thread() {
			@Override
			public void run() {
				for(int i=0;i<src.size();i++){
					System.out.print(src.get(i));
				}
				System.out.print('n');
				while (true) {
					for(int j=0;j<2;j++){
						dest.add(src.get(0));
						System.out.println(src.get(0));
						src.remove(0);
					}
					// 间隔时间60毫秒
					try {
						Thread.sleep(600);
					} catch (InterruptedException e) {
						break;
					}
					if (src.size() == 0)
						break;
				}
			}

		}.start();

Answer 10

让我想想，看看能行不。。O(∩_∩)O谢谢

Answer 11

你会出现java.lang.IndexOutOfBoundsException的

Answer 12

21行  src.get(pos++)  改成 src.remove(pos++)


不知道我理解的对不对，是不是你想要的效果

Answer 13

这个是神马啊，，我就是想要那种push的那个，，我不会写。。。╮(╯﹏╰）╭

Answer 14

我不会那个堆栈的那个东西 不会写。。。~~~~(>_<)~~~~

Answer 15

那个堆栈的要怎么写( ⊙o⊙ )哇

Answer 16

你用堆栈,每次pop两个,同时源栈就会少2个,扔到目标list中就好了

Answer 17

对，是这样的，用线程。。。每次放入dest两个数据，就进行一次传递，然后把dest中的两个数据删掉。。

Answer 18

你的问题是从source list 移动 10 个元素到  dest list ,每次移动 2 个, 用多线程来处理,是不?