线程

1.一个线程就是一个对象，需要继承Thread类或者extends Runnable接口。

其中public class Thread extends Object implements Runnable （两者的关系）

创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法

class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

然后，下列代码会创建并启动一个线程：

 

     PrimeThread p = new PrimeThread(143);
     p.start();

第二种创建方法：

创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示： 
 
     class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
 
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
 


然后，下列代码会创建并启动一个线程： 
 

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();
 

每个线程都有一个标识名，多个线程可以同名。如果线程创建时没有指定标识名，就会为其生成一个新名称。

2.

启动线程的方法是start(),而不是run().run()函数只是类似于main()函数。

 

如果是调用run()函数，则线程会顺序运行。如果调用start(),这样程序可以正常完成交互式运行

package org.thread.demo; class MyThread extends Thread{ private String name; public MyThread(String name) { super(); this.name = name; } public void run(){ for(int i=0;i<10;i++){ System.out.println("线程开始："+this.name+",i="+i); } } } package org.thread.demo; public class ThreadDemo01 { public static void main(String[] args) { MyThread mt1=new MyThread("线程a"); MyThread mt2=new MyThread("线程b"); mt1.run(); mt2.run(); } } 

 

但是，此时结果很有规律，先第一个对象执行，然后第二个对象执行，并没有相互运行。在

jdk 的文档中可以发现，一旦调用start()方法，则会通过JVM找到run()方法。（如果使用start方法，则mt1和mt2会交替进行）

注：线程的作用就是线程和线程之间的程序会交互进行。线程和线程后面的代码也会交替进行

 

 

3。Runnable 接口中没有对start()方法的定义，但是可以通过new Thread(引用runnable的类的对象).start().启动线程，这样可以实现资源的共享

 

public class MyThreadThread extends Thread { private int ticket=5; public void run(){ for(int i=0;i<5;i++){ if(this.ticket>0){ System.out.println("Thread开始卖ticket"+this.ticket--); } } } } public class MyThreadRunnable implements Runnable { private int ticket=5; public void run(){ for(int i=0;i<5;i++){ if(this.ticket>0){ System.out.println("Runnable开始卖ticket"+this.ticket--); } } } } 

 

public class ThreadTicket { public static void main(String[] args) { MyThreadThread mt1=new MyThreadThread(); MyThreadThread mt2=new MyThreadThread(); MyThreadThread mt3=new MyThreadThread(); mt1.start();//每个线程都各卖了10张，共卖了30张票 mt2.start();//但实际只有10张票，每个线程都卖自己的票 mt3.start();//没有达到资源共享 MyThreadRunnable bb1= new MyThreadRunnable(); new Thread(bb1).start(); new Thread(bb1).start(); new Thread(bb1).start(); } }  

 

运行结果：

 

Thread开始卖ticket5

Thread开始卖ticket4

Thread开始卖ticket3

Thread开始卖ticket5

Thread开始卖ticket5

Thread开始卖ticket4

Thread开始卖ticket3

Thread开始卖ticket2

Thread开始卖ticket4

Thread开始卖ticket2

Thread开始卖ticket3

Thread开始卖ticket2

Runnable开始卖ticket4

Runnable开始卖ticket3

Runnable开始卖ticket1

Thread开始卖ticket1

Runnable开始卖ticket5

Runnable开始卖ticket2

Thread开始卖ticket1

Thread开始卖ticket1

 

 

 

 

注：守护程序：

守护线程与普通线程的唯一区别是：当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则不会退出

public   static   void   main   是在一个非守护线程中运行的，但是JVM中并不一定只有这个非守护线程，你可以在程序中启动多个非守护线程，JVM同样也会等待它们的退出。所以并非主线程（运行main方法的线程）退出就一定退出JVM。

守护线程的唯一用途就是告诉JVM不需要等待它退出，当JVM中所有的线程都是守护线程的时候就可以正常的退出了

JVM会等待所有非守护线程退出以后才会退出！
public   static   void   main(String[]   args)   {
    new   MyThread().start();
//如果MyThread不是守护线程，那么JVM必须等待MyThread退出了才会退出
//并不是退出main函数就已经表示JVM可以结束！
}

 

如果这个线程的结果是一定要等待的（如写数据文件，计算逻辑等），如果是后台的垃圾回收这种当然就是守护线程。