黑马程序员技术交流社区

标题: 一道网上的面试题 [打印本页]
作者: xclyijin    时间: 2015-7-27 17:11
标题: 一道网上的面试题
今天积极备战面试，可是网上搜索完面试题后我奔溃了。。。。好像还挺难。
这是其中一道，我想了很久，如果是真的面试，估计就挂了。。。。。。。。
声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
     给数组中添加数据，每一个线程为数组添加3个数据即可。
作者: zuopiezi    时间: 2015-7-27 17:17
  1. import java.lang.reflect.Array;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import java.util.Random;
  6. import java.util.concurrent.CopyOnWriteArrayList;
  7. import java.util.concurrent.Executor;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.ScheduledExecutorService;
  10. import java.util.concurrent.ScheduledThreadPoolExecutor;
  11. import java.util.concurrent.TimeUnit;

  13. //声明一个共享数组，起两个线程，
  14. //两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，
  15. //每一个线程为数组添加3个数据即可。
  16. public class Test21 {
  17.         //写一个类实现Runnable接口，创建两个Thread对象传入该类
  18.            //多线程操作共享数组需要同步synchronize
  19.        public static void main(String...args){
  20.                fillArray fa = new fillArray();
  21.                Thread t1 = new Thread(fa);
  22.                Thread t2 = new Thread(fa);
  23.                t1.start();
  24.                t2.start();
  25.        }
  26. }
  27. class fillArray implements Runnable{
  28.     //定义共享数组
  29.         int[] arr = new int[6];
  30.     Random r = new Random();
  31.     int count = 0;
  32.         public void run() {
  33.                 // 同步代码块
  34.                 synchronized(r){
  35.                         while(count<arr.length){
  36.                                 int num = r.nextInt(20);
  37.                                 System.out.println(Thread.currentThread().getName()+"向数组中加入了"+num);
  38.                                 arr[count] = num;
  39.                                 count++;
  40.                                 try {
  41.                                         r.wait(500);
  42.                                 } catch (Exception e) {
  43.                                         e.printStackTrace();
  44.                                 }
  45.                         }
  46.                 }
  47.                 System.out.println(Arrays.toString(arr));
  48.         }
  49.        
  50. }
复制代码
作者: 心在左边跳    时间: 2015-7-27 17:51
我写的好麻烦，不知道谁有简便算法
  1. public class Demo {

  3.         public static void main(String[] args) {
  4.                 Res res = new Res();
  5.                 new Thread(new MyThread1(res)).start();
  6.                 new Thread(new MyThread2(res)).start();

  8.         }

  10. }

  12. class Res {
  13.         private int arr[] = new int[10];
  14.         private int index = 0;
  15.         private boolean flag = true;

  17.         public boolean isFlag() {
  18.                 return flag;
  19.         }

  21.         public void setFlag(boolean flag) {
  22.                 this.flag = flag;
  23.         }

  25.         public synchronized void add1() {
  26.                 if (flag) {
  27.                         try {
  28.                                 wait();
  29.                         } catch (InterruptedException e) {
  30.                                 e.printStackTrace();
  31.                         }
  32.                 }
  33.                 arr[index] = (int) (Math.random() * 10);
  34.                 System.out.println(Thread.currentThread().getName() + ":" + arr[index]);
  35.                 index++;
  36.                 setFlag(!flag);
  37.                 notify();

  39.         }

  41.         public synchronized void add2() {
  42.                 if (!flag) {
  43.                         try {
  44.                                 wait();
  45.                         } catch (InterruptedException e) {
  46.                                 e.printStackTrace();
  47.                         }
  48.                 }
  49.                 arr[index] = (int) (Math.random() * 10);
  50.                 System.out.println(Thread.currentThread().getName() + ":" + arr[index]);
  51.                 index++;
  52.                 setFlag(!flag);
  53.                 notify();

  55.         }
  56. }

  58. class MyThread1 implements Runnable {
  59.         private Res res;
  60.         private int count = 0;

  62.         public MyThread1(Res res) {
  63.                 this.res = res;
  64.         }

  66.         @Override
  67.         public void run() {
  68.                 while (count < 3) {
  69.                         res.add1();
  70.                         count++;
  71.                 }
  72.         }

  74. }

  76. class MyThread2 implements Runnable {
  77.         private Res res;
  78.         private int count = 0;

  80.         public MyThread2(Res res) {
  81.                 this.res = res;
  82.         }

  84.         @Override
  85.         public void run() {
  86.                 while (count < 3) {

  88.                         res.add2();
  89.                         count++;
  90.                 }
  91.         }
  92. }
复制代码







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2