《day14---多线程入门_进阶》

 /*
 多线程：

 进程：正在执行中的程序，一个应用程序启动后在内存中运行的那片空间。进程具有动态性和并发性。

 线程：进程中的一个执行单元。负责进程中的程序的运行的。一个进程中至少要有一个线程。
       一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

 程序启动了多线程，有什么应用呢？
 可以实现多部分程序同时执行。专业术语称之为 并发。

 多线程的使用可以合理使用cpu的资源，如果线程过多会导致降低性能。

 cpu在处理程序时是通过快速切换完成的。在我们看来好像随机一样。
 */

 //03-多线程-主线程的运行方式&创建线程的第一种方式。
 /*
 通过代码来演示之前和之后的区别。

 在之前的代码中，jvm启动后，必然有一个执行路径(线程)从main方法开始的，
 一直执行到main方法结束。这个线程在java中称之为主线程。

 当主线程在这个程序中执行时，如果遇到了循环而导致停留时间过长，
 就无法执行下面的程序。
 可不可以实现一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。
 实现多部分的代码同时执行。
 这就是多线程技术可以解决的问题。

 该如何创建线程呢？ 

 通过API中的英文Thread搜索。查到了Thread类。
 通过阅读Thread类中的描述。
 创建线程有两种方式。
 1，继承Thread类。
     1.1 定义一个类去继承Thread.
     1.2 重写run方法。
     1.3 创建子类对象。就是创建线程对象。
     1.4 调用strat方法。开启线程并让线程执行，同时还会告诉jvm调用run方法。

 为什么要这么做？
 继承Thread类：因为Thread类描述线程事物，具备线程应该有的功能。
 那为什么不直接创建Thread类的对象呢？
 Thread t1 = new Thread();
 t.strat();//这么做没有错，但是该strat调用的是Thread类中的run方法，
 而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让
 线程执行的代码。

 创建线程的目的是什么？是为了建立单独的执行路径，让多部分代码实现同时执行。
 也就是线程创建并执行需要给定代码(线程的任务)。
 对于之前所讲的主线程，它的任务定义在了主函数中。
 自定义的线程需要执行的任务都定义在run方法中。
 Thread类中run方法内部的任务并不是我们所需要的。只要重写这个run方法就行了。
 既然Thread类已经定义了线程任务的位置，只要在位置中定义任务代码即可。
 所以进行了重写run方法动作。

 多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。
 进行方法的压栈和弹栈。

 当执行线程的任务结束了，线程自动在栈内存中释放了。
 当所有的执行线程都结束了，进程就结束了。

 //获取线程名称。可以通过Thread类中的一个currentThreadd()方法。怎么获取名称呢？
 getName();

 Thread.currentThread().getName();

 主线程的名称是：main
 自定义的线程名称是：Thread-1 线程多个时，数字依次递增。
 */

 class Demo extends Thread
 {
     private String name;
     Demo(String name)
     {
         this.name = name;
     }
     public void run()
     {
         //int[] arr = new int[3];
         //System.out.println(arr[4]);
         for(int x=1;x<=20;x++)
         {
             System.out.println("name="+name+"....."+Thread.currentThread().getName()+".."+x);
         }
     }
 }

 class ThreadDemo1
 {
     public static void main(String[] args)
     {
         //创建了两个线程对象。
         Demo d1 = new Demo("小强");
         Demo d2 = new Demo("旺财");
         d2.start();//将d2这个线程开启。
         d1.run();//由主线程负责。

         /*
         线程对象调用run方法和调用start方法的区别？
         调用run方法不开启线程，仅是对象调用方法。
         调用start开启线程，并让jvm调用run方法在开启的线程中执行。
         */
     }
 }

 //创建线程的第二种方式。
 /*
 创建线程的第二种方式：使用Runnable接口。
 1,定义类实现Runnable接口。//避免了单继承的局限性。
 2，覆盖接口中的run方法。将线程任务代码定义到run方法中。
 3，创建Thread类的对象。        //只有创建Thread类的对象才可以创建线程。
 4，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
     因为线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象。
     所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的任务。
 5，调用Thread类的strat方法开启线程。

 第二种方式实现Runnable接口避免了单继承的局限性。所以，较为常用。
 实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
 继承Thread类，线程对象和线程任务耦合在一起，一旦创建Thread类的子类对象，既是线程对象，又有线程任务。
 实现Runnable接口，将线程任务单独分离出来封装成对象。类型就是Runnable接口类型。
 Runnable接口对线程对象和线程任务解耦。

 //通过源代码的形式讲解了一些Runnable接口的子类对象作为参数传递给Thread构造函数的原因。
 class Thread{
     private Runnable target;

     Thread(Runnable traget)
     {
         this.target = target;
     }
     public void run() {
         if (target != null) {
             target.run();
         }
     }
     public void strat()
     {
         run();
     }
 }

 Demo d = new Demo();//Runnable d = new Demo();
 Thread t = new Thread(d);
 t.strat();
 */

 class Demo implements Runnable
 {
     private String name;
     Demo(String name)
     {
         this.name = name;
     }
     //覆盖了接口Runnable的run方法。
     public void run()
     {
         for(int x=1;x<20;x++)
         {
             System.out.println("name="+name+"....."+Thread.currentThread().getName()+".."+x);
         }
     }
 }
 class ThreadDemo2
 {
     public static void main(String[] args)
     {
         //创建Runnable子类的对象。注意它并不是线程对象。
         Demo d = new Demo("Demo");
         //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
         Thread t1 = new Thread(d);
         Thread t2 = new Thread(d);
         t1.start();
         t2.start();

         System.out.println(Thread.currentThread().getName()+"------>");
     }
 }

 //多线程的安全问题产生及原因以及解决思路
 /*
 案例：售票的例子。

 售票的动作需要同时执行。所以要使用多线程技术。

 发生了线程安全问题，出现了错误的数据；0 -1 -2

 问题产生的原因：
 1，线程任务在操作共享的数据。
 2，线程任务操作共享数据的代码有多条（运算有多个）。

 解决思路：
 只要让一个线程在执行线程任务时，将多条操作共享数据的代码执行完，
 在执行过程中，不要让其他线程参与运算就行了。

 代码体现：
 Java中解决此问题通过代码块来完成的，
 这个代码代码块称之为同步代码块 synchronized
 格式：
 synchronized(对象)
 {
     //需要被同步的代码。
 }

 同步好处：同步代码块解决了多线程安全问题。

 同步的弊端：
 降低了程序的性能。

 同步前提：
 必须保证多个线程在同步中使用的是同一个锁
 解决了什么问题？当多线程安全问题发生时，加入了同步后，问题依旧发生时，
 就要通过这个同步的前提来判断同步是否正确。
 */

 class Ticket implements Runnable
 {
     //1，描述票的数量
     private int tickets = 100;

     //2,售票的动作。这个动作需要被多线程执行，那就是线程任务代码，
     //需要定义在run方法中。
     //记住，线程任务中通常都有循环结构。
     private Object obj = new Object();
     public void run()
     {
         while(true)
         {
             synchronized(obj)//如果写 new Object() 则用的就不是同一个锁。
             {
                 if(tickets > 0)
                 {
                     //要让线程在这里稍停，模拟问题的发生。sleep 看到了 0 -1 -2 这样的错误的数据，这就是传说中的安全问题。
                     try{Thread.sleep(1);}catch(InterruptedException e){/*未写处理方式，后面讲*/}

                     System.out.println(Thread.currentThread().getName()+"...."+tickets--);//打印线程名称
                 }
             }
         }
     }
 }

 class ThreadDemo3
 {
     public static void main(String[] args)
     {
         //1，创建Runnable接口的子类对象。
         Ticket t = new Ticket();

         //创建四个线程对象。并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
         Thread t1 = new Thread(t);
         Thread t2 = new Thread(t);
         Thread t3 = new Thread(t);
         Thread t4 = new Thread(t);

         //3，开启四个线程
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }