A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

写一个线程类MyThread,该线程实现了Runnable接口,写一个main方法,用for循环创建5个线程对象。需求如下:
① 利用线程类的构造函数输出:"创建线程4"。
(备注:当创建一个线程的时候,标记为1,再次创建一个线程的时候,标记为2,所以输出的"创建线程4"就是创建的第四个线程)
② 在run方法中输出:“线程X :计数Y”,当执行次数达到6次的时候,退出。
(备注:其中“线程X”为第X个线程,“计数Y”为该线程的run方法执行了多少次)



18 个回复

倒序浏览
class MyThread implements Runnable
{
       
        private int i ;
        private int y = 1;

         MyThread(int i)
        {
                this.i =i;
                  System.out.println("创建线程"+i);
        }
       

        public void run()
        {
                for(int z=-0;z<6;z++)
                {
                        System.out.println("线程"+i+":技数"+y);
                        y++;
                }

        }
}
class  Test_19
{
        public static void main(String[] args)
        {
               
               
               
                for(int i=1;i<6;i++)
                {       
                       
                        new Thread(new MyThread(i)).start();       
                }
        }
}
回复 使用道具 举报
D:\Java0921\day27>java Test_1
创建线程1
创建线程2
线程1:技数1
线程1:技数2
创建线程3
线程1:技数3
线程3:技数1
线程3:技数2
线程3:技数3
线程2:技数1
线程3:技数4
线程1:技数4
线程1:技数5
创建线程4
线程1:技数6
线程3:技数5
线程3:技数6
线程2:技数2
线程2:技数3
线程4:技数1
创建线程5
线程4:技数2
线程4:技数3
线程2:技数4
线程4:技数4
线程4:技数5
线程4:技数6
线程5:技数1
线程2:技数5
线程5:技数2
线程2:技数6
线程5:技数3
线程5:技数4
线程5:技数5
线程5:技数6
回复 使用道具 举报
结果是这样,是题的需求么:'(
回复 使用道具 举报
还没看到线程,过来看看
回复 使用道具 举报
顶一下!!!!!
回复 使用道具 举报
每天来一次 加油努力!!!
回复 使用道具 举报
miosec 中级黑马 2015-3-26 19:56:43
8#
真的很不错哟!努力学习吧.虽然这道题我也不知道咋弄,但是支持你!
回复 使用道具 举报
看看就好
回复 使用道具 举报
第一个应该是在MyThread类中创建一个静态成员(static int i),在构造函数中i++;第二个是在在MyThread类中创建一个普通成员(int j),在run方法中j++,这样每个线程都有自己的计数Y。
回复 使用道具 举报
public class ThreadTest {
    public static void main(String[] args) {
        AtomicInteger num = new AtomicInteger();
        List<MyThread> list=new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new MyThread(num));
        }
        while (true){
            for (MyThread m:list) {
                Thread thread = new Thread(m);
                thread.start();
            }
        }
    }
}
public class MyThread implements Runnable {
    private AtomicInteger cout=new AtomicInteger();
    private int num;
    @Override
    public void run() {
        if(cout.intValue()<6) {
            System.out.println("线程" + num + ":计数" + cout.incrementAndGet());
        }
        else {
            return;
        }

    }


    public MyThread(AtomicInteger num) {
        this.num=num.incrementAndGet();
        System.out.println("创建线程" + num);
    }
}

你看看这样行不行。

回复 使用道具 举报
看看来的                 
回复 使用道具 举报
  1. package com.itheima.test;

  2. import java.util.ArrayList;
  3. import java.util.List;

  4. public class Demo1 {

  5.         public static void main(String[] args) {
  6.                 List<MyThread> list = new ArrayList<MyThread>();
  7.                 // 创建五个线程
  8.                 for (int i = 1; i <= 5; i++) {
  9.                         list.add(new MyThread(i));
  10.                 }

  11.                 System.out.println("=======================");

  12.                 // 开启五个线程
  13.                 for (int i = 0; i < list.size(); i++) {
  14.                         list.get(i).start();
  15.                 }
  16.         }
  17. }

  18. class MyThread implements Runnable {
  19.         // 线程的名称
  20.         private String threadName;
  21.         // 线程已经执行的次数
  22.         private int count;
  23.         private Thread thread = new Thread(new Runnable() {

  24.                 @Override
  25.                 public void run() {
  26.                         // 如果已经执行了5次,则是需要执行最后一次即可
  27.                         while (count <= 5) {
  28.                                 count++;
  29.                                 MyThread.this.run();
  30.                         }
  31.                 }
  32.         });

  33.         public MyThread(int id) {
  34.                 super();
  35.                 // 为线程的名称进行赋值
  36.                 this.threadName = "线程" + id;
  37.                 System.out.println("创建线程" + id);
  38.         }

  39.         @Override
  40.         public void run() {
  41.                 // 线程的任务
  42.                 System.out.println(threadName + " : 计数" + count);
  43.         }

  44.         public void start() {
  45.                 // 开启线程
  46.                 thread.start();
  47.         }
  48. }
复制代码


回复 使用道具 举报 0 1
看天书了,支持下
回复 使用道具 举报
  1. class MyThread implements Runnable{
  2.         private int i;
  3.        
  4.         public MyThread(int i) {
  5.                 super();
  6.                 this.i = i;
  7.         }
  8.         Object obj = new Object();
  9.         @Override
  10.         public void run() {
  11.                 int count = 1;

  12.                         if(Thread.currentThread().getName().endsWith("4")){
  13.                                 System.out.println("创建了"+Thread.currentThread().getName());
  14.                         }
  15.                         while(count!=7){
  16.                                 synchronized (obj) {
  17.                                        
  18.                                         System.out.println(Thread.currentThread().getName()+":"+"计数"+count);
  19.                                         count++;
  20.                                 }
  21.                         }
  22.                
  23.                
  24.         }
  25.        
  26. }

  27. public class Test11 {

  28.         /**
  29.          * 写一个线程类MyThread,该线程实现了Runnable接口,写一个main方法,用for循环创建5个线程对象。需求如下:
  30. ① 利用线程类的构造函数输出:"创建线程4"。
  31. (备注:当创建一个线程的时候,标记为1,再次创建一个线程的时候,标记为2,所以输出的"创建线程4"就是创建的第四个线程)
  32. ② 在run方法中输出:“线程X :计数Y”,当执行次数达到6次的时候,退出。
  33. (备注:其中“线程X”为第X个线程,“计数Y”为该线程的run方法执行了多少次)
  34.          */
  35.         public static void main(String[] args) {
  36.                 // TODO Auto-generated method stub
  37.                 for(int x = 1; x<=5; x++){
  38.                         new Thread(new MyThread(x),"线程"+x).start();
  39.                 }

  40.         }

  41. }
复制代码

这样不知道是不是楼主要的...
回复 使用道具 举报
class MyThread implements Runnable
{
        private int count = 0;//用于记录线程执行的次数
        private int no ;//记录线程的线程号
        private static int num = 0;//共享数据,用于记录创建了几个线程
        MyThread()
        {
                num++;//创建一个线程计数器自增1
                this.no = num ;//每次创建一个线程给其分配一个线程号
                if(num==4)
                        System.out.println("创建线程4");
        }

        public void run()
        {
                while(count<6)
                {
                        System.out.println("线程"+this.no+":"+"计数"+(++count));
                }
        }
}

class MyThreadDemo
{
        public static void main(String[] args)
        {
                for(int i=0;i<5;i++)
                {
                        new Thread(new MyThread()).start();
                }
        }
}
------------------------------------------------------------------------------
运行结果:

D:\java>java MyThreadDemo
线程1:计数1
线程3:计数1
创建线程4
线程2:计数1
线程2:计数2
线程2:计数3
线程3:计数2
线程1:计数2
线程3:计数3
线程2:计数4
线程5:计数1
线程4:计数1
线程5:计数2
线程2:计数5
线程3:计数4
线程1:计数3
线程1:计数4
线程1:计数5
线程1:计数6
线程3:计数5
线程3:计数6
线程2:计数6
线程5:计数3
线程5:计数4
线程5:计数5
线程5:计数6
线程4:计数2
线程4:计数3
线程4:计数4
线程4:计数5
线程4:计数6
回复 使用道具 举报

楼上的很赞!支持
回复 使用道具 举报
package com.heima.IO;

import java.util.Enumeration;
import java.util.Vector;
/*写一个线程类MyThread,该线程实现了Runnable接口,写一个main方法,用for循环创建5个线程对象。
需求如下:
① 利用线程类的构造函数输出:"创建线程4"。
(备注:当创建一个线程的时候,标记为1,再次创建一个线程的时候,标记为2,
所以输出的"创建线程4"就是创建的第四个线程)
② 在run方法中输出:“线程X :计数Y”,当执行次数达到6次的时候,退出。
(备注:其中“线程X”为第X个线程,“计数Y”为该线程的run方法执行了多少次) */


public class Day1_ClassTest2  {
public static void main(String[] args) {
MyThread mt = new MyThread();
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
MyThread mt3 = new MyThread();
MyThread mt4 = new MyThread();

new Thread(mt, mt.name).start();
new Thread(mt1, mt1.name).start();
new Thread(mt2, mt2.name).start();
new Thread(mt3, mt3.name).start();
new Thread(mt4, mt4.name).start();

       
}
}

class MyThread implements Runnable{
        String name;
        static int i = 1;
        static int y=1;
        static Object o = new Object();
        public MyThread(){
                name = "线程"+i;
                System.out.println("创建线程"+i);
                i++;
        }
       
        public void run(){
                while(y<7){
                        synchronized(o){
                                if(y>=7){
                                        return;
                                }
                               
                                System.out.println(Thread.currentThread().getName()+":计数"+y++);
                        }
                }
        }
       
       
}
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马