声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，每一个线程为数组添加3个数据即可。

求代码  求思路？？？？？{:3_46:}

我今早面试就做了这个题目~~~~~紧张死了

邓士林 发表于 2015-1-16 14:48
刚才回答你的时候已经有个想法，等我忙好这点东西，我去试试，然后在拿出来探讨，你有何高见，指导下 ...

设置flag标志，交替判断，尝试失败（丫的还是随机的）。。。。:dizzy:有可能代码有问题，锁理解的不透彻，看你高见学习下

当我遇上你 发表于 2015-1-16 14:05
能做到严格的交替运行么

刚才回答你的时候已经有个想法，等我忙好这点东西，我去试试，然后在拿出来探讨，你有何高见，指导下

邓士林 发表于 2015-1-16 14:04
不一定会抢到

能做到严格的交替运行么

当我遇上你 发表于 2015-1-16 13:47
一个线程sleep()另外一个线程一定会抢到CPU执行权吗？应该有例外一个线程执行多次吧,不过通过3来控制应该 ...

不一定会抢到

邓士林 发表于 2015-1-16 00:10

一个线程sleep()另外一个线程一定会抢到CPU执行权吗？应该有例外一个线程执行多次吧,不过通过3来控制应该最多执行3次

张周飞 发表于 2015-1-16 10:24
for(String s : myThread.a)
                System.out.println(s);
这段的  ：  myThread.a ------对 ...

可以的，这是高级for循环，编译也没问题，因为我事先知道数组是Stirng类型，所以可以直接这样，编译结果：
---------- 编译 ----------
输出完成 (耗时 0 秒) - 正常终止

邓士林 发表于 2015-1-16 00:10

for(String s : myThread.a)
                System.out.println(s);
这段的  ：  myThread.a ------对象 . 数组     好像编译不通过吧？能这样写吗？

突然发现个问题，还是改好再来

1. class ArrayThread implements Runnable
   
2. {
   
3.         public String a[] = new String[6];
   
4.         private String name;
   
5.         private int index = 0;
   
6.         public ArrayThread(String name)
   
7.         {
   
8.                 this.name = name;
   
9.         }
   
10. 
    
11.         public void run()
    
12.         {
    
13.                 for(int i=0;i<3;i++)
    
14.                 {
    
15.                         try
    
16.                         {
    
17.                                 Thread.sleep(10);
    
18.                         }
    
19.                         catch (InterruptedException ex)
    
20.                         {
    
21.                                 ex.getMessage();
    
22.                         }
    
23.                         print();
    
24.                 }
    
25. }
    
26.         public synchronized void print()
    
27.         {
    
28.                 a[index] = Thread.currentThread().getName();
    
29.                 System.out.println("线程：" +a[index] +"数据被添加");
    
30.                 index++;
    
31.         }
    
32. }
    
33. class TreadTestDemo
    
34. {
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 ArrayThread myThread = new ArrayThread("线程");
    
38.                 Thread t1 = new Thread(myThread);
    
39.                 Thread t2 = new Thread(myThread);
    
40.                 t1.start();
    
41.                 t2.start();
    
42. 
    
43.                 try
    
44.                 {
    
45.                         Thread.sleep(1000);
    
46.                 }
    
47.                 catch (InterruptedException ex)
    
48.                 {
    
49.                         ex.getMessage();
    
50.                 }
    
51.                 System.out.println("打印数组内容：");
    
52.                 for(String s : myThread.a)
    
53.                 System.out.println(s);
    
54.         }
    
55. }
    

复制代码

1. 
   
2. public class MultiThread{
   
3. 
   
4.        
   
5.         private String[] sharedArray = new String[6];
   
6.        
   
7.         private int currentIndex = 0;
   
8.        
   
9.        
   
10.         public class MyThread extends Thread{
    
11.                 public void run(){
    
12.                        
    
13.                         for (int i = 0; i < 3; i++) {
    
14.                                 addItem();
    
15.                                 try {
    
16.                                         Thread.sleep(2000);
    
17.                                 } catch (InterruptedException e) {
    
18.                                 };
    
19.                         }
    
20.                        
    
21.                 }
    
22.                
    
23.         }
    
24.        
    
25.         public synchronized void addItem(){
    
26.                 String someThing = "someThing";
    
27.                 this.sharedArray[this.currentIndex] = someThing;
    
28.                 this.currentIndex++;
    
29.         }
    
30.         public static void main(String[] args) {
    
31.                 MultiThread mt = new MultiThread();
    
32.                 MyThread th1 = mt.new MyThread();
    
33.                 MyThread th2 = mt.new MyThread();
    
34.                 th1.start();
    
35.                 th2.start();
    
36.                 try {
    
37.                         th1.join();
    
38.                         th2.join();
    
39.                 } catch (InterruptedException e) {
    
40.                 }
    
41.                 for (int i = 0; i < mt.sharedArray.length; i++) {
    
42.                         System.out.println(mt.sharedArray[i]);
    
43.                 }
    
44.         }
    
45. }
    

复制代码

是想要这种吗

我的思路：两个线程用同一个锁(如ThreadDemo.class作为锁)，一个添加一个数据完成后，把锁让出来给另一个线程
添加数据