Java基础——多线程(持续更新中)

首先我们先了解一下进程和线程的关系，以及这两者有什么区别。

{

1:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。

2:什么是进程?
    通过任务管理器我们就看到了进程的存在。
    而通过观察，我们发现只有运行的程序才会出现进程。
    进程：就是正在运行的程序。
    进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
    
3:多进程有什么意义呢?
    单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
    举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
    也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。
    并且呢，可以提高CPU的使用率。
    
    问题：
        一边玩游戏，一边听音乐是同时进行的吗?
        不是。因为单CPU在某一个时间点上只能做一件事情。
        而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。
        
4:什么是线程呢?
    在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。
    线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
    单线程：如果程序只有一条执行路径。
    多线程：如果程序有多条执行路径。
    
5:多线程有什么意义呢?
    多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
    程序的执行其实都是在抢CPU的资源，CPU的执行权。
    多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
    我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。

大家注意两个词汇的区别：并行和并发。
 *        前者是逻辑上同时发生，指在某一个时间内同时运行多个程序。
 *        后者是物理上同时发生，指在某一个时间点同时运行多个程序。

* Java程序的运行原理：
 *         由java命令启动JVM，JVM启动就相当于启动了一个进程。
 *         接着有该进程创建了一个主线程去调用main方法。

思考题：
 *         jvm虚拟机的启动是单线程的还是多线程的?
 *             多线程的。
 *             原因是垃圾回收线程也要先启动，否则很容易会出现内存溢出。
 *             现在的垃圾回收线程加上前面的主线程，最低启动了两个线程，所以，jvm的启动其实是多线程的。

}

如何建立一个执行路径呢？

通过查询API文档 java.lang.Thread类

该类的描述中有创建线程的两种方式

1.继承Thread类

(1).将类声明为 Thread 的子类

(2).该子类应重写 Thread 类的 run 方法

(3).创建子类对象就是创建线程对象

(4).调用Thread类中的start方法就可以执行线程,炳辉调用run()方法

Eg:计算大于某一规定值的质数的线程可以写成：

 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();

start()开启线程后,都会执行run()方法.说明run()方法中存储的是线程要运行的代码;所以,记住自定义线程的任务代码都存储在run()方法中

2.声明实现 Runnable 接口

(1).定义一个类,实现runnable

(2).覆盖runnable接口中的run方法,先线程要运行的任务代码存储到该方法中

(3).描述Thread类创建线程对象,并将实现了Runnable接口的对象作为Thread类的构造函数的参数进行传递

(4).调用Thread类的start方法,开启线程

   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();

At:调用Start方法和调用run方法的区别?

调用start会开启线程,让开启的线程去执行run方法中的线程任务,

　直接调用run方法,线程并未开启,去执行run方法的只有主线程(main)。

-----------------------------------------------方式一:继承Thread----------------------------------------------------------------

/*
 * 如何获取线程对象的名称呢?
 * public final String getName():获取线程的名称。
 * 如何设置线程对象的名称呢?
 * public final void setName(String name):设置线程的名称
 *
 * 针对不是Thread类的子类中如何获取线程对象名称呢?
 * public static Thread currentThread():返回当前正在执行的线程对象
 * Thread.currentThread().getName()
 */

 public class MyThread extends Thread {

     public MyThread() {
     }

     public MyThread(String name){
         super(name);
     }

     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x);
         }
     }
 }

MyThread

 public class MyThreadDemo {
     public static void main(String[] args) {
         // 创建线程对象
         //无参构造+setXxx()
         // MyThread my1 = new MyThread();
         // MyThread my2 = new MyThread();
         // //调用方法设置名称
         // my1.setName("林青霞");
         // my2.setName("刘意");
         // my1.start();
         // my2.start();

         //带参构造方法给线程起名字
         // MyThread my1 = new MyThread("林青霞");
         // MyThread my2 = new MyThread("刘意");
         // my1.start();
         // my2.start();

         //我要获取main方法所在的线程对象的名称，该怎么办呢?
         //遇到这种情况,Thread类提供了一个很好玩的方法:
         //public static Thread currentThread():返回当前正在执行的线程对象
         System.out.println(Thread.currentThread().getName());
     }
 }

MyThreadDemo

/*
 * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
 * 当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。
 *
 */

 public class ThreadDaemon extends Thread {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x);
         }
     }
 }

ThreadDaemon

 public class ThreadDaemonDemo {
     public static void main(String[] args) {
         ThreadDaemon td1 = new ThreadDaemon();
         ThreadDaemon td2 = new ThreadDaemon();

         td1.setName("关羽");
         td2.setName("张飞");

         // 设置守护线程
         td1.setDaemon(true);
         td2.setDaemon(true);

         td1.start();
         td2.start();

         Thread.currentThread().setName("刘备");
         for (int x = 0; x < 5; x++) {
             System.out.println(Thread.currentThread().getName() + ":" + x);
         }
     }
 }

ThreadDaemonDemo

/*
 * public final void join():等待该线程终止。
 */

 public class ThreadJoin extends Thread {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x);
         }
     }
 }

ThreadJoin

 public class ThreadJoinDemo {
     public static void main(String[] args) {
         ThreadJoin tj1 = new ThreadJoin();
         ThreadJoin tj2 = new ThreadJoin();
         ThreadJoin tj3 = new ThreadJoin();

         tj1.setName("李渊");
         tj2.setName("李世民");
         tj3.setName("李元霸");

         tj1.start();
         try {
             tj1.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         tj2.start();
         tj3.start();
     }
 }

ThreadJoinDemo

/*
 * 我们的线程没有设置优先级,肯定有默认优先级。
 * 那么，默认优先级是多少呢?
 * 如何获取线程对象的优先级?
 *         public final int getPriority():返回线程对象的优先级
 * 如何设置线程对象的优先级呢?
 *         public final void setPriority(int newPriority)：更改线程的优先级。
 *
 * 注意：
 *         线程默认优先级是5。
 *         线程优先级的范围是：1-10。
 *         线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。
 *         
 * IllegalArgumentException:非法参数异常。
 * 抛出的异常表明向方法传递了一个不合法或不正确的参数。
 *
 */

 public class ThreadPriority extends Thread {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x);
         }
     }
 }

ThreadPriority

 public class ThreadPriorityDemo {
     public static void main(String[] args) {
         ThreadPriority tp1 = new ThreadPriority();
         ThreadPriority tp2 = new ThreadPriority();
         ThreadPriority tp3 = new ThreadPriority();

         tp1.setName("东方不败");
         tp2.setName("岳不群");
         tp3.setName("林平之");

         // 获取默认优先级
         // System.out.println(tp1.getPriority());
         // System.out.println(tp2.getPriority());
         // System.out.println(tp3.getPriority());

         // 设置线程优先级
         // tp1.setPriority(100000);

         //设置正确的线程优先级
         tp1.setPriority(10);
         tp2.setPriority(1);

         tp1.start();
         tp2.start();
         tp3.start();
     }
 }

ThreadPriorityDemo

/*
 * 线程休眠
 *        public static void sleep(long millis)
 */

 public class ThreadSleep extends Thread {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x + ",日期：" + new Date());
             // 睡眠1秒钟
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

ThreadSleep

 public class ThreadSleepDemo {
     public static void main(String[] args) {
         ThreadSleep ts1 = new ThreadSleep();
         ThreadSleep ts2 = new ThreadSleep();
         ThreadSleep ts3 = new ThreadSleep();

         ts1.setName("林青霞");
         ts2.setName("林志玲");
         ts3.setName("林志颖");

         ts1.start();
         ts2.start();
         ts3.start();
     }
 }

ThreadSleepDemo

/*
 * public final void stop():让线程停止，过时了，但是还可以使用。
 * public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。
 */

 import java.util.Date;

 public class ThreadStop extends Thread {
     @Override
     public void run() {
         System.out.println("开始执行：" + new Date());

         // 休息10秒钟
         try {
             Thread.sleep(10000);
         } catch (InterruptedException e) {
             // e.printStackTrace();
             System.out.println("线程被终止了");
         }

         System.out.println("结束执行：" + new Date());
     }
 }

ThreadStop

 public class ThreadStopDemo {
     public static void main(String[] args) {
         ThreadStop ts = new ThreadStop();
         ts.start();

         // 中断sleep
         try {
             Thread.sleep(3000);
             // ts.stop();
             ts.interrupt();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

ThreadStopDemo

/*
 * public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
 * 让多个线程的执行更和谐，但是不能靠它保证一人一次。
 */

 public class ThreadYield extends Thread {
     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             System.out.println(getName() + ":" + x);
             Thread.yield();
         }
     }
 }

ThreadYield

 public class ThreadYieldDemo {
     public static void main(String[] args) {
         ThreadYield ty1 = new ThreadYield();
         ThreadYield ty2 = new ThreadYield();

         ty1.setName("林青霞");
         ty2.setName("刘意");

         ty1.start();
         ty2.start();
     }
 }

ThreadYieldDemo

=============================方式2:实现Runnable接口==========================

/*
 * 方式2：实现Runnable接口
 * 步骤：
 *         A:自定义类MyRunnable实现Runnable接口
 *         B:重写run()方法
 *         C:创建MyRunnable类的对象
 *         D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
 */

 public class MyRunnable implements Runnable {

     @Override
     public void run() {
         for (int x = 0; x < 100; x++) {
             // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
             System.out.println(Thread.currentThread().getName() + ":" + x);
         }
     }

 }

MyRunnable

 public class MyRunnableDemo {
     public static void main(String[] args) {
         // 创建MyRunnable类的对象
         MyRunnable my = new MyRunnable();

         // 创建Thread类的对象，并把C步骤的对象作为构造参数传递
         // Thread(Runnable target)
         // Thread t1 = new Thread(my);
         // Thread t2 = new Thread(my);
         // t1.setName("林青霞");
         // t2.setName("刘意");

         // Thread(Runnable target, String name)
         Thread t1 = new Thread(my, "林青霞");
         Thread t2 = new Thread(my, "刘意");

         t1.start();
         t2.start();
     }
 }

MyRunnableDemo