多线程

如果要想进行多线程的开发，则和程序的主类一样，线程也需要一个线程的主体类。但是所有的线程主体类有两种定义的形式：一种是继承Thread类，另外一种是实现Runnable接口。很明显按照面向对象的概念来讲解使用Runnable接口会更加的合适，因为避免了单继承局限。

继承Thread类

Thread类是线程操作之中最为重要的一个类，如果要定义线程主体类，直接继承此类，同时覆写此类之中的run()方法即可，而run()方法就相当于是线程中的主方法一样

范例：定义线程主体类

class MyThread extends Thread {     private String title ;     public MyThread(String title) {         this.title = title ;     }     @Override     public void run() {         for (int x = 0; x < 10; x++) {              System.out.println(this.title + "，x = " + x);         }     } }

           线程主体类一旦定义完成之后，如果要想启动多线程，肯定首先要实例化MyThread类的对象，而后调用里面的方法，可是这个时候不能够直接调用run()方法，因为run()方法只是定义了线程的功能，但并不表示启动线程，如果要想启动线程，则必须利用Thread类中的start()方法完成：public void start()。

启动多线程

public class TestDemo {     public static void main(String[] args) {         MyThread mt1 = new MyThread("线程A");         MyThread mt2 = new MyThread("线程B");         MyThread mt3 = new MyThread("线程C");         mt1.start();         mt2.start();         mt3.start();     } }

           可以发现现在所有的线程都在交替运行状态下执行。就证明了，多个线程互相抢占CPU的资源。

实现Runnable接口

多线程主体类的另外一种实现方式是采用了Runable接口，可以避免单继承的局限。

范例：通过Runnable实现线程主体类

class MyThread implements Runnable {     private String title;     public MyThread(String title) {         this.title = title;     }     @Override     public void run() {         for (int x = 0; x < 10; x++) {              System.out.println(this.title + "，x = " + x);         }     } }

启动多线程。

public class TestDemo {     public static void main(String[] args) {         MyThread mt1 = new MyThread("线程A");         MyThread mt2 = new MyThread("线程B");         MyThread mt3 = new MyThread("线程C");         new Thread(mt1).start();         new Thread(mt1).start();         new Thread(mt2).start();         new Thread(mt3).start();     } }

           结论：不管是何种方式实现的多线程，都必须通过Thread类的start()方法启动。

多线程的两种实现方式联系与区别

对于多线程的两种实现方式如果从代码结构上讲肯定使用Runnable接口要比使用Thread类更加合适，因为可以避免单继承的局限，但是除了这点区别之外，Runnable接口和Thread类之间实际上还是会存在联系的。

Thread类的继承结构。

public class Thread extends Object implements Runnable

           发现Thread类实际上就是Runnable接口子类。那么对于此时的程序结构如下。

区别：使用Runnable实现的多线程要比使用Thread类实现多线程具备更明显的数据共享优势。数据共享指的是多个线程操作同一资源的情况。

范例：利用Runnable实现（Runnable里面没有start()方法，必须借助于Thread类启动）

package cn.mldn.test; class MyThread implements Runnable {     private int ticket = 5 ; // 一共5张票     @Override     public void run() {         for (int x = 0; x < 50; x++) {              if (this.ticket > 0) {   // 还有票                  System.out.println("卖票，ticket = " + this.ticket --);              }         }     } } public class TestDemo {     public static void main(String[] args) {         MyThread mt = new MyThread() ;         new Thread(mt).start();         new Thread(mt).start();         new Thread(mt).start();     } }

           此时定义了三个Thread类的对象，而且这三个类的对象同时占用了一个Runnable接口子类的对象引用，所以就表示这三个线程对象指向同一块空间，里面有ticket这个属性。

多线程的两种实现方式及区别

           · 多线程可以继承Thread类或实现Runnable接口来定义；

           · 使用Runnable接口可以避免单继承的局限，同时可以更好的表示出数据共享的概念。而Thread类是Runnable接口的子类，如果要想启动多线程一定需要Thread类的start()方法完成。

线程的命名和取得

构造方法：public Thread(Runnable target, String name)；

                      设置名字：public final void setName(String name)；

                     取得名字：public final String getName()。

MyThread mt = new MyThread() ;

        new Thread(mt, "线程A").start();

        new Thread(mt).start();

        new Thread(mt, "线程B").start();

        new Thread(mt).start();

实际上这个时候如果没有为线程对象设置名字，那么会由系统按照“Thread-xxx”的形式自动命名，以保证每一个线程都有自己独立的名字。

问题：请问每一个JVM进程至少启动几个线程？

           两个：main、GC。

线程的休眠

如果现在希望让线程的每次执行放慢速度，则可以通过线程的休眠操作完成，操作的方法：

                     ·休眠：public static void sleep(long millis) throwsInterruptedException，单位是毫秒。

class MyThread implements Runnable {

    @Override

    public void run() {

        for (int x = 0; x < 100; x++) {

             try {

                 Thread.sleep(3000);

             } catch (InterruptedException e) {

                 e.printStackTrace();

             }

             System.out.println(Thread.currentThread().getName() + "，x = " + x);

        }

    }

}

线程的优先级

由于所有的线程都要去抢占资源，所以理论上那个线程优先级高，那个线程就应该先执行，如果要想操作线程的优先级可以使用如下的两个方法完成：

                     ·设置优先级：public final void setPriority(int newPriority)；

                     ·取得优先级：public final int getPriority()。

           可以发现设置和取得优先级的时候所取得类型全部是数字，而对于这个数字可以通过如下的三个常量设置：

                     ·最高优先级：public static final int MAX_PRIORITY，10；

                     ·中等优先级：public static final int NORM_PRIORITY，5；

                     · 最低优先级：public static final int MIN_PRIORITY，1

MyThread mt = new MyThread();

        Thread t1 = new Thread(mt, "线程A");

        Thread t2 = new Thread(mt, "线程B");

        Thread t3 = new Thread(mt, "线程C");

        t1.setPriority(Thread.MIN_PRIORITY);

        t3.setPriority(Thread.MIN_PRIORITY);

        t2.setPriority(Thread.MAX_PRIORITY);

        t1.start();

        t2.start();

        t3.start(); 

既然主方法本身也是一个线程，那么主线程的优先级是什么呢？

public class TestDemo {     public static void main(String[] args) {         System.out.println(Thread.currentThread().getPriority());     } }

           主线程为中等优先级。

同步与死锁