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原样发到帖子上啊?

tsldxszd 发表于 2016-3-6 22:06
再定一个变量等于1.让他自增就完了，还用什么parseint转换。。简单的不用，非得玩高科技，88 ...

哇哦,一看你头像就知道你是个装(波一)小能手.一个老婆都生二胎的人了能不能稍微成熟一点
你不回答自然有人回答,还非要出来秀一波.看你1.30就社招完了,现在还这么闲,该不会是没通过吧哦哟.那你想想排在你前面的人是不是每个人都应该说你一句辣鸡呢?
尺有所短寸有所长,编程这种东西最重要的是学习能力而不是会一点东西到处装波一,人家才学了一个月,您社招都结束两个月了有什么老脸在这儿秀优越感啊.

//顺便说一句,点那个尖括号可以发代码模式的文档.

再见.

tsldxszd 发表于 2016-3-6 22:06
再定一个变量等于1.让他自增就完了，还用什么parseint转换。。简单的不用，非得玩高科技，88 ...

另外论坛交流问题就好好交流,这么大了有点涵养,各种装B 没什么意思.入行有先后,指点指点可以,我都虚心接受,但你这样说话真的是有点恶心.

tsldxszd 发表于 2016-3-6 22:06
再定一个变量等于1.让他自增就完了，还用什么parseint转换。。简单的不用，非得玩高科技，88 ...

public class Demo_Thread10
{ public static void main(String[] args) throws InterruptedException {
        //long start=System.currentTimeMillis();
        MyRunnable mr=new MyRunnable();
        for(int i=0;i<10;i++)
        {
                new Thread(mr,"Thread-"+i).start();
        }
       

        //long end=System.currentTimeMillis();
       
       
}
       
}
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);
                        System.out.println("1-100的运算结果为"+sum);
                }
}
你说的是这种?我没觉得parseInt有什么不好,出错了也好发现问题.

tsldxszd 发表于 2016-3-6 21:51
你这参数也不对啊！小于11算怎么个意思？

每次计算1-10,11-20,21-30.这样啊  count初始值改成1吧

tsldxszd 发表于 2016-3-6 21:50
而且这个不用join。。。刚才那个是 赋值，然后遍历打印，怕 没赋值就遍历了所以join，这个 直接 出结果了！ ...

刚会用join用用啊,我想着的是只打印最后结果,这里是要改..

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

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

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

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

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);
                }
}

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，还有一个视频 ...

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

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

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

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

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

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

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

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)