java多线程,MultpleThread

一、定义线程

   第1种方法：扩展java.lang.Thread类                   

                       Thread类中有个run()方法，其子类应该重写该方法！

      -------------<继承java.lang.Thread，并重写它的run()方法，将线程的执行主体放入其中>------------

 public class ThreadTest extends Thread

{
     public void run()

     {
         // 在这里编写线程执行的主体
       // do something
    }
}

   第2种方法: 实现java.lang.Runnable接口

                     使用接口Runnable的对象创建一个线程时，启动该线程时将会在独立运行的线程中调用（Runnable实现的）对象的run方法

    ----------------<实现java.lang.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中>-----------

 public class RunnableTest implements Runnable

 {
       public void run()

        {
           // 在这里编写线程执行的主体
           // do something
      }
}

二、实例化线程

      对应第一种方法：直接new即可

    对应第二种方法,则用Thread的构造方法！

       如：Thread(Runnable target);

               Thread(Runnable target, String name);

三、启动线程

      用线程对象调用start()方法，而不是run()方法！

      在调用start()方法之前，线程仅仅是有意个Thread对象，还没有运行不是一个真正的线程！

      在调用start()方法之后，启动新的执行线程（具有新的调用栈？多个线程共享进程的资源！）， 该线程从仅有Thread对象的状态

      转移到可运行状态！

      当该线程获得机会执行时，其目标run()方法将运行!

继承Thread类的启动方式：

 public class ThreadStartTest

 {
      public static void main(String[] args)

      {
            // 创建一个线程实例
            ThreadTest tt = new ThreadTest();
           // 启动线程
           tt.start();
      }
}

      实现Runnable接口的启动方式：

public class RunnableStartTest

 {
        public static void main(String[] args)

       {
           // 创建一个线程实例
           Thread t = new Thread(new RunnableTest());
            // 启动线程
            t.start();
      }
}

注：对于Java,run()方法是新线程要调用的方法。并不是启动新的线程！

      run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。

四、例子

public class TestThread extends Thread {
    public TestThread(String name) {
        super(name);
    }   

    public void run() {
        for(int i = 0; i < 5; i++) {
            for(long k = 0; k < 10000000; k++);
            System.out.println(this.getName() + " : " + i); 
        }                  //  getName(); 这个函数在哪个类中
    }   

    public static void main(String[] args) {
        Thread t1 = new TestThread("张 三");
        Thread t2 = new TestThread("李 四");

        //Thread.currentThread(); 获取当前线程的名字

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

public class DoSomething implements Runnable {
    private String name;

    public DoSomething(String name) {
        this.name = name;
    }   

    public void run() {
        for (int i = 0; i < 5; i++) {
            for (long k = 0; k < 10000000; k++);
            System.out.println(name + ":" + i); 
        }   
    }   
}
public class TestRunnable {
    public static void main(String[] args) {
        DoSomething ds1 = new DoSomething("张 三");
        DoSomething ds2 = new DoSomething("李 四");

        Thread t1 = new Thread(ds1);
        Thread t2 = new Thread(ds2);

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

五、区别

这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰。