Go语言视频零基础入门到精通

admin

方法一： 用继承Thread实现
实例：



代码
  
  
   
   package
    threadtest13;

   //
   多线程的写法2，用两种情况变换，

   //
   情况1：新建一个对象，两个线程共享一个对象。另外是新建两个对象，两个线程用两个对象

   //
   情况2：int i=0；拿到run（）外面与在run（）里面两种情况
   。
//上面4种情况可以排列组合试一下

   public
   class
    Thread13 {


   public
   static
   void
    main(String args[]){
MyThread myThread
   =
   new
    MyThread();


   //
    MyThread myThread2= new MyThread();
   //
   2
   

   
Thread t1
   =
   new
    Thread(myThread);
Thread t2
   =
   new
    Thread(myThread);

   //
   Thread t2= new Thread(myThread2);
   //
   2
   

   t1.start();
t2.start();
}

}


   class
    MyThread
   extends
    Thread {

   //
    int i=0;
   //
   1
   

   public
   void
    run() {
String name
   =
    Thread.currentThread().getName();
String inf
   =
   Thread.currentThread().toString();

   long
    idnum
   =
    Thread.currentThread().getId();

   for
   (
   int
    i
   =
   0
   ;i
   <
   10
   ;i
   ++
   ){
   //
   不管是新建一个对象，还是两个对象，
   //
   2，都是打印20个数据

   //
    for(;i<10;i++){
   //
   新建一个对象的时候，打印11个左右的数据 ,新建两个对象的时候，
   //
   2，会打印20个数据。
   //
   1
   

   System.out.println(
   "
   i----------
   "
   +
   i
   +
   "
   ,thread name==
   "
   +
    name

   +
   "
   ,threadid==
   "
   +
    idnum
   +
   "
   ,thread inf==
   "
   +
   inf);
}
}
}





   
  

  
实例：
  


  
  package
   com.thread.test;


  public
  class
   ThreadTest
  extends
   Thread {

  public
   ThreadTest(String str){
  //
  用构造函数控制线程的名字，如果不写，默认是thread-整数
  

  super
  (str);
}

@Override

  public
  void
   run() {

  synchronized
  (
  this
  ){

  for
  (
  int
   i
  =
  0
  ;i
  <
  10
  ;i
  ++
  ){
  //
  控制run的内部这些东西执行的次数，不加这句，run只执行一次。
  

  System.out.println(i
  +
  getName());

  try
   {
sleep((
  long
  )(Math.random()
  *
  1000
  ));
}
  catch
   (InterruptedException e) {

  //
   TODO Auto-generated catch block
  

  e.printStackTrace();
}

}

  //
  for循环结束
  

  System.out.println(
  "
  for循环结束
  "
  +
  getName());
}


  super
  .run();
}


  /*
  
* 此方法可添加也可以不填加，start都能够调用。
* @Override
public synchronized void start() {
// TODO Auto-generated method stub
super.start();
}
  */
  



  public
  static
  void
   main(String args[]){

  new
   ThreadTest(
  "
  su
  "
  ).start();

  new
   ThreadTest(
  "
  zhu
  "
  ).start();

}
}

  

  



  
上面方法两个线程不能同步。
方法二：用“实现”Runnable方法实现
实例：



代码
  
  
   
   package
    threadtest12;

   //
   多线程的写法1
   

   public
   class
    Thread12 {


   public
   static
   void
    main(String args[]) {
MyThread myThread
   =
   new
    MyThread();

   //
   myThread.run();

   //
   把这个MyThread包装称为Thread
   

   Thread t1
   =
   new
    Thread(myThread);
Thread t2
   =
   new
    Thread(myThread);
t1.start();
t2.start();

}

}


   class
    MyThread
   implements
    Runnable {

@Override

   public
   void
    run() {

   //
    TODO Auto-generated method stub
   

   String name
   =
    Thread.currentThread().getName();
String inf
   =
   Thread.currentThread().toString();

   long
    idnum
   =
    Thread.currentThread().getId();

   for
   (
   int
    i
   =
   0
   ;i
   <
   10
   ;i
   ++
   ){
System.out.println(
   "
   aaaaa----------
   "
   +
   "
   ,thread name==
   "
   +
    name

   +
   "
   ,threadid==
   "
   +
    idnum
   +
   "
   ,thread inf==
   "
   +
   inf);
}
}

}

   
  

  
两个共享一个thread对象，并发调用，20条数据
  
  
实例：
  


  
  /*
  
*
*
* 这段代码用实现接口来做
* 可以让类extends继承其他类
  */
  


  package
   com.thread.test1;


  public
  class
   ThreadTest1
  implements
   Runnable{
String threadName;


  public
   ThreadTest1(String str){
threadName
  =
  str;
}

@Override

  public
  void
   run() {

  //
   TODO Auto-generated method stub
  

  for
  (
  int
   i
  =
  0
  ;i
  <
  10
  ;i
  ++
  ){
System.out.println(
  "
  执行第
  "
  +
  i);

  try
   {
Thread.sleep(
  1000
  );
}
  catch
   (InterruptedException e) {

  //
   TODO Auto-generated catch block
  

  e.printStackTrace();
}

  //
  System.out.println("执行完第"+i);
  

  }
System.out.println(
  "
  结束
  "
  );
}


  public
  static
  void
   main(String[] args){

  /*
  
* 这段跟下面的作用是一样的。。。new的ThreadTest1的对象不能调用start方法
* ThreadTest1 threadTest1=new ThreadTest1("h");
Thread thread1=new Thread(threadTest1);
thread1.start();
  */
  


  new
   Thread(
  new
   ThreadTest1(
  "
  su
  "
  )).start();
}

}