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接口的类的实例。

【后面的话】

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

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

——TT

巴特西

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

最新文章

热门文章