Java：多线程<一>

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

程序运行时，其实是CPU在执行程序的进程，为了提高工作效率一个进程可以有多个线程。

Java的多线程：

其实我们之前就见过Java的线程，main就是Java的一个线程，还有另一个条线程总是和main同时运行，那就是垃圾回收线程。

Java的线程有四种状态：

1，被创建：new Thread

2，运行（就绪）：JVM调用Thread的start方法执行Thread的run中的内容

3，冻结：sleep(毫秒)，wait()-notify()

4，消亡

Java可以通过继承Thread类和实现Runnable接口实现多线程技术。

通过继承Thread类实现多线程：

方法：

1，创建自定义的类继承Thread类

2，覆盖Thread类中的run方法

3，建立自定义的线程类的子类对象，即创建线程对象

4，调用start方法让JVM启动自定义线程（其实就是告诉JVM去运行自定义的run方法中的内容）
class DefinedThread extends Thread//自定义线程类继承Thread类

{

    ...

    public void run()

    {

        ...//复写Thread类中的run方法，定义该线程执行的内容

    }

    ...

}

class MultThread

{

    public static void main(String[] args)//main就是一个线程

    {

        DefinedThread dt = new DefinedThread();//创建线程对象

        dt.start();//启动线程

    }

}

通过实现Runnable接口实现多线程：

1，创建自定义的类实现Runnable接口

2，覆盖接口中的run方法

3，通过Thread类创建线程对象，并将自定义类的对象作为参数传递给Thread类的构造器

4，Thread类对象调用start方法开启线程

class DefinedThread implements Runnable//自定义类实现Runnable接口

{

    ...

    public void run()

    {

        ...//复写接口的run方法，定义该线程执行的内容

    }

    ...

}

class MultThread

{

    public static void main(String[] args)//main就是一个线程

    {

        DefinedThread dt = new DefinedThread();

        Thread t = new Thread(dt);//把自定义类的子类对象当作参数传递给Thread构造器

        t.start();//线程对象t调用start方法开启线程

    }

}

Thread和Runnable之间的关系：

1，一个类只能继承一个类，而可以实现多个接口，就这点而言Thread有局限性，Runnable扩展性好

2，Thread对象调用Thread(Runnable run)或者Thread(Runnable run, String name)构造方法创建线程，使用的是同一个Runnable实例对象内的资源，就这点而言，Runnable适合资源共享。（当然继承Thread类，使用static变量也能共享资源，但这样比较麻烦而且static的生命周期长）

3，通过Thread类的定义 public class Thread extends Object implements Runnable ，可以看出Thread类其实也实现了Runnable接口，不过Thread中有start方法，而Runnable中没有，所以实现了Runnable的对象的run中的内容想要让JVM调用就必须把该对象传递给Thread的，由Thread的对象调用start方法启动线程从而运行run中的内容。

小例子：假如有4个窗口售票，票从1号到100号，我们先看继承Thread的MyThread类实现
 class MultThread

 {

     public static void main(String[] args)

     {

         Thread t1 = new MyThread("窗口1");

         Thread t2 = new MyThread("窗口2");

         Thread t3 = new MyThread("窗口3");

         Thread t4 = new MyThread("窗口4");

         t1.start();

         t2.start();

         t3.start();

         t4.start();

     }

 }

 class MyThread extends Thread

 {

     private static int tick = 1;

     MyThread(String name)

     {

         super(name);

     }

     public void run()

     {

         while(tick<=100)

         {

             System.out.println(this.getName()+"售出"+tick+"号票");

             tick++;

         }

     }

 }
通过实现了Runnable接口的MyR类
 class MultThread

 {

     public static void main(String[] args)

     {

         MyR r = new MyR();

         Thread t1 = new Thread(r,"窗口1");

         Thread t2 = new Thread(r,"窗口2");

         Thread t3 = new Thread(r,"窗口3");

         Thread t4 = new Thread(r,"窗口4");

         t1.start();

         t2.start();

         t3.start();

         t4.start();

     }

 }

 class MyR implements Runnable

 {

     private int tick = 1;

     public void run()

     {

         while(tick<=100)

         {

             System.out.println(Thread.currentThread().getName()+"售出"+tick+"号票");

             tick++;

         }

     }

 }
但是对于双核或者多核的CPU来说这样会带来程序的风险，比如有可能出现1号票被卖了2次的情况，所以为了线程的安全性引出了同步的概念，这个笔记记录在下一节。