package com.halei.test;

import java.util.Random;

public class ThreadTest extends Thread {
    // 数组share索引
    public int index = 0;                       

    public static void main(String[] args) throws Exception {
            // share用于保存2个线程添加的数据
            String[] share = new String[6];       
            //为了提高方法的拓展性,定义数组放在了主函数中,而AddData类内创建该类引用,则可以访问该数组,这样就免除了要用单利设计模式的烦恼,就算创建多个AddData对象,也都是访问该数组
            ThreadTest tt = new ThreadTest();                                                                //主方法创建本类对象,后面要作为其他匿名类参数.
            Thread t1 = new Thread(new AddData(share, tt), "线程A");
            Thread t2 = new Thread(new AddData(share, tt), "线程B");
            t1.start();
            t2.start();

            // 当2个线程执行完，才执行下面的main线程程序
          //延长主线程生命周期,这样就确保了index伴随子线程一直存在并且唯一,下转51行,(this.share[tt.index++]在子线程中要一直访问index)
            t1.join();                                                                               
            t2.join();

            // 遍历share保存的数据
            for (int i = 0; i < share.length; i++) {
                    //打印主线程名字和数组元素,其中数组元素包含子线程名字和String[] data = { "第一个数据", "第二个数据", "第三个数据" }中的数据
                    System.out.println(Thread.currentThread().getName() + "--"
                                    + share[i]);                                       
            }
    }

}
class AddData implements Runnable {

    private String[] share;
    private ThreadTest tt;                                       

    public AddData(String[] share, ThreadTest tt) {
            this.share = share;
            this.tt = tt;
    }

    @Override
    public void run() {
            String[] data = { "第一个数据", "第二个数据", "第三个数据" };
            synchronized (share) {
                    for (int i = 0; i < data.length; i++) {
                            //下面这段代码我怀疑是在实现存储动作的自然化,貌似没什么用......没看懂.健壮性?
                            /*try {
                                    Thread.sleep((new Random().nextInt(10) + 1) * 10);
                                    
                            } catch (InterruptedException e) {
                                    e.printStackTrace();
                            }*/
                            this.share[tt.index++] = Thread.currentThread().getName() + ":"
                                            + data[i];
                    }
            }
    }
}
___________________________________________________________________________________________
另外,怎么能像其他人那样把eclipse原样发到帖子上啊?

我完全看不懂你的add在干嘛，你的thread.sleep睡10-90毫秒我也完全看不出来你睡那么点时间能体现什么

最主要的是，你一个继承thread 一个实现runnable 为什么还要用thread 去start

tsldxszd 发表于 2016-3-5 12:07
我完全看不懂你的add在干嘛，你的thread.sleep睡10-90毫秒我也完全看不出来你睡那么点时间能体现什么 ...

有些代码中间加入sleep是为了模拟不确定的数据操作,因为他在这段代码里没什么实际用处所以我就让他少睡了一会,开发中后期添加代码的时候替换一下就行了呗.

tsldxszd 发表于 2016-3-5 12:09
最主要的是，你一个继承thread 一个实现runnable 为什么还要用thread 去start

这个代码中已经有注释了,也是我自己的理解,代码本身是笔试题题库中的经典案例.我也没全理解,就算能解读我自己暂时也写不出这样的程序.再者就算一个代码有瑕疵,该借鉴的地方也值得学习.先尝试着去理解,再去质疑.我还是觉得在论坛中交流问题还是谦虚点好.

public class duox
{
        public static void main(String[] args)
        {
                int [] ar = new int[6];
                cun c = new cun(ar);
                Thread t1 = new Thread(c);
                Thread t2 = new Thread(c);
                t1.start();t2.start();
                try
                {
                        t1.join();t2.join();
                } catch (InterruptedException e)
                {
                        // TODO

class cun implements Runnable
{
         int []ar;
         int index = 0;
         
         public cun(int[] i)
        {
                super();
                this.ar = i;
        }

        public synchronized void run()
         {
                String s = Thread.currentThread().getName();
                 for (int i = 0; i < 3; i++)
                {
                         int temp = (int) (Math.random()*10+1)

ar[index++]=temp;
                        System.out.println(s+"往arr["+index+"]存入了"+ar[index-1]);
                }
         }
}

Thread-1往arr[1]存入了3
Thread-1往arr[2]存入了4
Thread-1往arr[3]存入了6
Thread-0往arr[4]存入了10
Thread-0往arr[5]存入了1
Thread-0往arr[6]存入了7
3461017

两分钟写的，发出来花10分钟，看我的，你看的那个写的非常烂

main函数里少个括号，少个打印数组，一开始粘帖不过来，自己加去。没加thread sleep。你自己加，没错，那个就是模拟添加的，加不加的随你，但是原题我记得是要求模拟的，你现在的代码等的那点时间和没有一样。随你用哪个随机数，反正我习惯这种了。你贴的代码真的槽点太多，别看了

除了这题，还有俩多线程题，一个是建10线程，求一到100的和，比如第一个算1-10.第二个11到20，还有一个视频有讲，卖票的。此外最好掌握如交替运行和死锁

多线程共享数据和两种方式的交替运行我写起来也是没什么问题的,就是觉得段代码的的逻辑有点匪夷所思,尝试着去解读了一下,jion 的用法之前也分析错了..是为了阻塞主线程用的.因为后面有打印.

tsldxszd 发表于 2016-3-6 13:48
除了这题，还有俩多线程题，一个是建10线程，求一到100的和，比如第一个算1-10.第二个11到20，还有一个视频 ...

你说的视频我去看看,就这样吧

tsldxszd 发表于 2016-3-6 13:48
除了这题，还有俩多线程题，一个是建10线程，求一到100的和，比如第一个算1-10.第二个11到20，还有一个视频 ...

你说的10个线程求和的那个,我投机了一下,就题论题的话没有比我这个简单的了.

tsldxszd 发表于 2016-3-6 13:48
除了这题，还有俩多线程题，一个是建10线程，求一到100的和，比如第一个算1-10.第二个11到20，还有一个视频 ...

package com.halei.test;

public class Demo_Thread10
{ public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();
        MyRunnable mr=new MyRunnable();
        Thread t1=new Thread(mr);
        Thread t2=new Thread(mr);
        Thread t3=new Thread(mr);
        Thread t4=new Thread(mr);
        Thread t5=new Thread(mr);
        Thread t6=new Thread(mr);
        Thread t7=new Thread(mr);
        Thread t8=new Thread(mr);
        Thread t9=new Thread(mr);
        Thread t10=new Thread(mr);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        t8.start();
        t9.start();
        t10.start();
        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
        t9.join();
        t10.join();
        long end=System.currentTimeMillis();
        System.out.println("1-100的运算结果为"+mr.sum+"运行时间为"+(end-start));
       
}
       
}
class MyRunnable implements Runnable
{
                int sum=0;
                public synchronized void run()
                {
                        int i=Integer.parseInt(Thread.currentThread().getName().replaceAll("Thread-",""));
                        for(int count=0;count<11;count++)
                        {
                                sum+=(i*10)+count;
                               
                        }
                        System.out.println(Thread.currentThread().getName()+":"+sum);
                }
}

w我靠，哥们你疯了？你这样不累？
for(int i = 0 ;i<10;i++)
new Thread(mr,"线程"+i).strat();
这样不就完了，你 这么写 不累？

而且这个不用join。。。刚才那个是 赋值，然后遍历打印，怕 没赋值就遍历了所以join，这个 直接 出结果了！
你还join他干嘛，你一个 线程打印一遍，打印10次就是最后结果。

你这参数也不对啊！小于11算怎么个意思？

再定一个变量等于1.让他自增就完了，还用什么parseint转换。。简单的不用，非得玩高科技，88