Java学习笔记（八）——java多线程

【前面的话】

实际项目在用spring框架结合dubbo框架做一个系统，虽然也负责了一块内容，但是自己的能力还是不足，所以还需要好好学习一下基础知识，然后做一些笔记。希望做完了这个项目可以写一些dubbo框架和spring框架方面的总结。

学习过程中的小知识点总结，基础知识，选择阅读。

【线程定义】

在学习操作系统的时候，学习过什么是进程，什么是线程，下面这只维基百科里面关于线程的定义，大家可以看一下：

定义：线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。

【实现方法】

1. 第一种继承：Thread类

 class 类名extends Thread{
   方法1；
   方法2；
   ……
   public void run(){
     实现代码
    }
 }

2. 第二种：实现Runnable接口

 class 类名 implements Runnable{
    方法1；
    方法2；
    ……
    public void run(){
      实现代码
    }
 }

【三段代码】

第一段代码，就是一个很简单，就是和多线程没有关系的一段测试代码。

第二段代码，使用继承Thread的方法实现多线程。

第三段代码，使用实现Runnable接口的方法实现多线程。

第一段代码：

 public class NoThreadTest {
     private String noThread1;
     public NoThreadTest(){
     }
     public NoThreadTest(String noThread1){
         this.noThread1=noThread1;
     }
     public void run(){
         for(int i=0;i<3;i++){
             System.out.println(noThread1+"非多线程运行结果                             "+i);
         }
     }
     public static void main(String[] args){
         NoThreadTest maintest1=new NoThreadTest("我是A");
         NoThreadTest maintest2=new NoThreadTest("我是B");
         maintest1.run();
         maintest2.run();
     }

执行结果：

 我是A非多线程运行结果                                 0
 我是A非多线程运行结果                                 1
 我是A非多线程运行结果                                 2
 我是B非多线程运行结果                                 0
 我是B非多线程运行结果                                 1
 我是B非多线程运行结果                                 2

第二段代码：

 public class ThreadTest extends Thread {
     private String Thread1;
     public ThreadTest(){
     }
     public ThreadTest(String Thread1){
         this.Thread1=Thread1;
     }
     public void run(){
         for(int i=0;i<3;i++){//可以参看评论5进行修改，效果会好一些。
             System.out.println(Thread1+"多线程运行结果                                 "+i);
         }
     }
     public static void main(String[] args){
         ThreadTest maintest1=new ThreadTest("我是A");
         ThreadTest maintest2=new ThreadTest("我是B");
         maintest1.run();
         maintest2.run();
         System.out.println("..............我是分割线........................");
         maintest1.start();
         maintest2.start();
     }
 }

执行结果：(每一次执行的结果都是不一样的，这只是其中的某一种)

 我是A多线程运行结果                                 0
 我是A多线程运行结果                                 1
 我是A多线程运行结果                                 2
 我是B多线程运行结果                                 0
 我是B多线程运行结果                                 1
 我是B多线程运行结果                                 2
 ..............我是分割线........................
 我是A多线程运行结果                                 0
 我是B多线程运行结果                                 0
 我是B多线程运行结果                                 1
 我是B多线程运行结果                                 2
 我是A多线程运行结果                                 1
 我是A多线程运行结果                                 2

第三段代码:

 public class ThreadTest2 implements Runnable {
     private String Thread1;
     public ThreadTest2(){
     }
     public ThreadTest2(String Thread1){
         this.Thread1=Thread1;
     }
     public void run(){
         for(int i=0;i<3;i++){//可以参看评论5，效果会好一些
             System.out.println(Thread1+"多线程运行结果                                 "+i);
         }
     }
     public static void main(String[] args){
         ThreadTest2 maintest1=new ThreadTest2("我是A");
         ThreadTest2 maintest2=new ThreadTest2("我是B");
         Thread maintest4=new Thread(maintest1);
         Thread maintest5=new Thread(maintest2);
         maintest1.run();
         maintest2.run();
         System.out.println("..............我是分割线1........................");
         maintest4.run();
         maintest5.run();
         System.out.println("..............我是分割线2........................");
         maintest4.start();
         maintest5.start();
     }
 }

执行结果：(每一次执行的结果都是不一样的，这只是其中的某一种)

 我是A多线程运行结果                                 0
 我是A多线程运行结果                                 1
 我是A多线程运行结果                                 2
 我是B多线程运行结果                                 0
 我是B多线程运行结果                                 1
 我是B多线程运行结果                                 2
 ..............我是分割线1........................
 我是A多线程运行结果                                 0
 我是A多线程运行结果                                 1
 我是A多线程运行结果                                 2
 我是B多线程运行结果                                 0
 我是B多线程运行结果                                 1
 我是B多线程运行结果                                 2
 ..............我是分割线2........................
 我是B多线程运行结果                                 0
 我是B多线程运行结果                                 1
 我是B多线程运行结果                                 2
 我是A多线程运行结果                                 0
 我是A多线程运行结果                                 1
 我是A多线程运行结果                                 2

【代码分析】

1. run方法和start方法的区别：

java核心技术中有这样一段话：不要调用Thread类或Runnable对象的run方法。直接调用run方法，只会执行同一个线程中的任务，而不会启动新线程。应该调用Thread.start方法。这个方法将创建一个执行run方法的新线程。

2. 在上面第三段代码中，ThreadTest2类，Thread类和Runnerable接口都实现了run方法。

1)Runnerable接口实现run方法

 public
 interface Runnable {
     /**
      * When an object implementing interface <code>Runnable</code> is used
      * to create a thread, starting the thread causes the object's
      * <code>run</code> method to be called in that separately executing
      * thread.
      * <p>
      * The general contract of the method <code>run</code> is that it may
      * take any action whatsoever.
      *
      * @see     java.lang.Thread#run()
      */
     public abstract void run();
 }

2)Thread类实现run方法。

 public void run() {
     if (target != null) {
         target.run();
     }
     }

3)为什么要说这个？因为这个实现是使用了代理模式。

代理:一个角色代表另一个角色来完成某些特定的功能。

举个例子：大家都买过衣服，所以在买衣服的时候，一般有下面的角色：

购物者：我们一般是从代理商那里买衣服，我们并不和制造商进行交涉，我们不关心衣服是如何生产出来的。

代理商：代理商是从制造商那里拿衣服，并且代理商可以提供一些简单的服务，比如裁剪裤子等。

制造商：制造衣服，并且批发衣服给代理商。

我们从上面的行为中可以抽象出，一个行为就是卖衣服这个行为在代理商和制造商都有，如果购物者要买衣服，也需要以代理商和制造商卖衣服为前提。

从上面我们可以抽象出三个角色，并不是和上面对应的哈。

抽象主题角色：这个使我们可以抽象出来的角色。就是卖衣服这个行为。

代理主题角色：中间商。

实际被代理角色：制造商。

代码：

• SellClothes.java(需要和接口名一样)

 //抽象主题角色：买衣服
 public interface SellClothes {
   void sellClothes();
 }

• Middleman.java

 //代理主题角色：中间商
 public class Middleman implements SellClothes{
   private SellClothes t;
   public Middleman(SellClothes t) {
    super();
    this.t = t;
   }
   public void sellClothes() {
       t.sellClothes();
       System.out.println("我是中间商，我买的是制造商的衣服");
       System.out.println("我是中间商，我还提供对裤子不合适的进行裁剪服务");
 }
 }

• SellClothes.java

 //实际被代理角色
 public class Manufacturer implements SellClothes{
   public void sellClothes() {
    System.out.println("我是制造商，我提供批发衣服服务");
   }
 }

• Test.java

 public class Test {
   public static void main(String[] args) {
    Manufacturer t = new Manufacturer();
    Middleman sellclothes = new Middleman(t);
    sellclothes.sellClothes();
   }
 } 

运行结果：

 我是制造商，我提供批发衣服服务
 我是中间商，我买的是制造商的衣服
 我是中间商，我还提供对裤子不合适的进行裁剪服务

    得出结论：

抽象主题角色：Runnable，提供run方法

代理主题角色：Thread类，提供run方法

实际被代理角色：ThreadTest2，也实现了run 方法

这就是代理主题模式，我希望我讲清楚了，哈哈

3. native关键字

在看到start()实现方法的时候，看到了如下一段代码：

   public synchronized void start() {
         /**
      * This method is not invoked for the main method thread or "system"
      * group threads created/set up by the VM. Any new functionality added
      * to this method in the future may have to also be added to the VM.
      *
      * A zero status value corresponds to state "NEW".
          */
         if (threadStatus != 0)
             throw new IllegalThreadStateException();
         group.add(this);
         start0();
         if (stopBeforeStart) {
         stop0(throwableFromStop);
     }
     }
 private native void start0();

然后我好奇，native是什么关键字：

一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现

【实现区别】

1. 三段代码

1)第一段：

 public class ThreadTest6 extends Thread {
     private int num=3;//定义飞机票的张数
     public void run(){
         for(int i=0;i<10;i++){
             if(num>0){
                 System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
             }
         }
     }
     public static void main(String[] args){
         ThreadTest6 threadtest1=new ThreadTest6();
         ThreadTest6 threadtest2=new ThreadTest6();
         ThreadTest6 threadtest3=new ThreadTest6();
         threadtest1.start();
         threadtest2.start();
         threadtest3.start();

     }
 }

结果：

 Thread-1飞机票还剩余num= 3
 Thread-2飞机票还剩余num= 3
 Thread-2飞机票还剩余num= 2
 Thread-2飞机票还剩余num= 1
 Thread-0飞机票还剩余num= 3
 Thread-0飞机票还剩余num= 2
 Thread-0飞机票还剩余num= 1
 Thread-1飞机票还剩余num= 2
 Thread-1飞机票还剩余num= 1

2)第二段：

 public class ThreadTest5 implements Runnable {
     private int num=3;//定义飞机票的张数
     public void run(){
         for(int i=0;i<10;i++){
             if(num>0){
                 System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
             }
         }
     }
     public static void main(String[] args){
         ThreadTest5 threadtest1=new ThreadTest5();
         ThreadTest5 threadtest2=new ThreadTest5();
         ThreadTest5 threadtest3=new ThreadTest5();
         Thread thread1=new Thread(threadtest1,"窗口1");
         Thread thread2=new Thread(threadtest2,"窗口2");
         Thread thread3=new Thread(threadtest3,"窗口3");
         thread1.start();
         thread2.start();
         thread3.start();
     }
 }

结果：

 窗口2飞机票还剩余num= 3
 窗口2飞机票还剩余num= 2
 窗口2飞机票还剩余num= 1
 窗口1飞机票还剩余num= 3
 窗口1飞机票还剩余num= 2
 窗口1飞机票还剩余num= 1
 窗口3飞机票还剩余num= 3
 窗口3飞机票还剩余num= 2
 窗口3飞机票还剩余num= 1

3)第三段：

 public class ThreadTest7 implements Runnable {
     private int num=3;//定义飞机票的张数
     public void run(){
         for(int i=0;i<10;i++){
             if(num>0){
                 System.out.println(Thread.currentThread().getName()+"飞机票还剩余num= "+num--);
             }
         }
     }
     public static void main(String[] args){
         ThreadTest7 threadtest1=new ThreadTest7();
         Thread thread1=new Thread(threadtest1,"窗口1");
         Thread thread2=new Thread(threadtest1,"窗口2");
         Thread thread3=new Thread(threadtest1,"窗口3");
         thread1.start();
         thread2.start();
         thread3.start();
     }
 }

结果：

 窗口1飞机票还剩余num= 3
 窗口1飞机票还剩余num= 2
 窗口1飞机票还剩余num= 1

2. 分析：

第一和第二段代码不管是使用Runnerable实现还是使用Thread实现，从结果可以看出三个线程每个线程均有num这个资源，如果把num看做是飞机票的话，那么每个线程都有三张飞机票。这不是我们实际中要得到的情况。

      要实现这个飞机售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。

      这就是第三段代码实现的结果，ThreadTest7只创建了一个资源对象——threadtest1。创建了三个线程，每个线程调用的是同一个threadtest1对象中的run()方法，访问的是同一个对象中的变量（num）的实例，这个程序满足了我们的需求。

3. 结论：

可见，实现Runnable接口相对于继承Thread类来说，有如下显著的好处： 
      (1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。 
      (2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。 
      (3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

【后面的话】

写一篇文章的过程是充满了乐趣的一次奇妙的旅程，有时“柳暗“，有时”花明“。但是当写完的时候如同一次旅行的结束，总会是有收获的。

分享：

1. 10层以下，走楼梯
2. 左手刷牙
3. 公交车读书
4. 持续早起早睡
5. 出门的时候记得，“伸手要纸钱“——身份证，手机，钥匙，纸巾，钱包。

——TT