JavaSE学习总结第23天_多线程1

 

23.01  多线程程序的引入

如果一个程序只有一个执行流程，所以这样的程序就是单线程程序。

如果一个程序有多条执行流程，那么，该程序就是多线程程序。

23.02  进程概述及多进程的意义

要想说线程，首先必须得知道进程，因为线程是依赖于进程存在的

进程:正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

 

多进程意义:多进程的作用不是提高执行速度，而是提高CPU的使用率

单进程计算机只能做一件事情。而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程)，所以我们常见的操作系统都是多进程操作系统。

比如:Windows，Mac和Linux等，能在同一个时间段内执行多个任务。

 

对于单核计算机来讲，游戏进程和音乐进程不是同时运行的，因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，且切换速度很快，所以，我们感觉游戏和音乐在同时进行，其实并不是同时执行的。

23.03  线程概述及多线程的意义

在一个进程内部又可以执行多个任务，而这每一个任务就可以看成是一个线程。线程是程序中单个顺序的控制流，是程序使用CPU的基本单位。

线程:

是进程中的单个顺序控制流，是一条执行路径

一个进程如果只有一条执行路径，则称为单线程程序。

一个进程如果有多条执行路径，则称为多线程程序。

多线程意义:   多线程的作用也不是提高执行速度，而是为了提高应用程序的使用率。

多个线程共享同一个进程的资源(堆内存和方法区)，但是栈内存是独立的，一个线程一个栈。所以他们仍然是在抢CPU的资源执行。一个时间点上只有能有一个线程执行。而且谁抢到，这个不一定，所以，造成了线程运行的随机性。

23.04  并行和并发的区别

注意两个词汇的区别:并行和并发

并行是逻辑上同时发生，指在某一个时间内同时运行多个程序

并发是物理上同时发生，指在某一个时间点同时运行多个程序

23.05  Java程序运行原理和JVM的启动是多线程的吗

Java程序运行原理:java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。

由于JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的

23.06  实现多线程及多线程方式1的思路

由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来。而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。Java是不能直接调用系统功能的，但是Java可以去调用C/C++写好的程序来实现多线程程序。由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类供我们使用。我们就可以实现多线程程序了。

Java提供的类 Thread

通过查看API，知道有2中方式实现多线程程序。

方式1:继承Thread类

步骤:

1:自定义类MyThread继承Thread类。

2:MyThread类重写run()方法

3:创建对象

4:启动线程

23.07  多线程方式1的代码实现

例:

 public class Practice
 {
     public static void main(String[] args)
     {
         //创建对象
         //MyThread mt = new MyThread();
         //run()方法直接调用其实就相当于普通的方法调用,所以看到的是单线程的效果
         //要想看到多线程的效果，就必须使用另一个方法:start()
         //mt.run();
         // 创建两个线程对象
         MyThread my1 = new MyThread();
         MyThread my2 = new MyThread();

         my1.start();
         my2.start();

     }
 }
 //继承Thread类
 class MyThread extends Thread
 {
     //重写run()方法
     @Override
     public void run()
     {
         // 一般来说，被线程执行的代码肯定是比较耗时的。所以用循环改进
         for (int x = 0; x < 200; x++)
         {
             System.out.println(x);
         }
     }
 }

run()和start()的区别

run():仅仅是封装被线程执行的代码，直接调用是普通方法

start():首先启动了线程，然后再由jvm去调用该线程的run()方法

继承Thread类的类为什么要重写run()方法?

不是类中的所有代码都需要被线程执行的。而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。

23.08  获取和设置线程对象名称

public final String getName():返回该线程的名称

public final void setName(String name):改变线程名称，使之与参数 name 相同。

例:

 public class Practice
 {
     public static void main(String[] args)
     {
 //        MyThread my1 = new MyThread();
 //        MyThread my2 = new MyThread();
 //
 //        //调用方法设置名称
 //        my1.setName("线程1");
 //        my2.setName("线程2");
 //        //启动线程
 //        my1.start();
 //        my2.start();

         //带参构造方法给线程起名字
          MyThread my1 = new MyThread("线程1");
          MyThread my2 = new MyThread("线程2");
          my1.start();
          my2.start();

         //获取main方法所在的线程对象的名称
         //public static Thread currentThread():返回当前正在执行的线程对象
         System.out.println(Thread.currentThread().getName());

     }
 }
 class MyThread extends Thread
 {

     public MyThread()
     {
         super();
     }

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

运行结果:

main
线程1:0(省略部分结果)
线程2:8(省略部分结果)

通过Thread类的getName( )方法可以获取线程的名称，默认的命名方式是:Thread-编号(从0开始)

为什么名称是:Thread-编号?

看源码:

 class Thread
 {
     private char name[];
     private static int threadInitNumber;
     private static synchronized int nextThreadNum()
     {
         return threadInitNumber++;
     }
     public Thread()
     {
         init(null, null, "Thread-" + nextThreadNum(), 0);
     }
     public final String getName()
     {
         return String.valueOf(name);
     }
     private void init(ThreadGroup g, Runnable target, String name,long stackSize)
     {
         init(g, target, name, stackSize, null);
     }

     private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc)
     {
         //省略部分代码
         this.name = name.toCharArray();
     }
 }

23.09  线程调度及获取和设置线程优先级

线程调度:

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？

线程有两种调度模型:

分时调度模型:所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型:优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

 

设置和获取线程优先级

public final int getPriority():返回线程的优先级。

public final void setPriority(int newPriority):更改线程的优先级。

例:

 public class Practice
 {
     public static void main(String[] args)
     {
         MyThread my1 = new MyThread();
         MyThread my2 = new MyThread();
         MyThread my3 = new MyThread();

         //设置优先级，最小为1，最大为10
         my3.setPriority(9);
         //获取优先级，默认为5
         System.out.println(my1.getPriority());//
         System.out.println(my2.getPriority());//
         System.out.println(my3.getPriority());//

         my1.start();
         my2.start();
         my3.start();//获取的 CPU 时间片相对多一些
     }
 }
 class MyThread extends Thread
 {
     @Override
     public void run()
     {
         for (int x = 0; x < 200; x++)
         {
             System.out.println(getName()+":"+x);
         }
     }
 }

23.10  线程控制之休眠线程

public static void sleep(long millis)throws InterruptedException

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

例:

 class MyThread extends Thread
 {
     @Override
     public void run()
     {
         for (int x = 0; x < 5; x++)
         {
             System.out.println(getName()+":"+x+":"+new Date());
             try
             {
                 //休眠1秒
                 Thread.sleep(1000);
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }
         }
     }
 }

23.11  线程控制之加入线程

public final void join()throws InterruptedException

等待该线程终止。

例:

 public class Practice
 {
     public static void main(String[] args)
     {
         MyThread my1 = new MyThread();
         MyThread my2 = new MyThread();
         MyThread my3 = new MyThread();

         my1.setName("线程1");
         my2.setName("线程2");
         my3.setName("线程3");

         my1.start();
         try
         {
             //等待线程1线程，线程1运行完成后，线程2线程3开始争夺资源
             my1.join();
         }
         catch (InterruptedException e)
         {
             e.printStackTrace();
         }
         my2.start();
         my3.start();
     }
 }

23.12  线程控制之礼让线程

public static void yield()

暂停当前正在执行的线程对象，并执行其他线程。

例:

 class MyThread extends Thread
 {
     @Override
     public void run()
     {
         for (int x = 0; x < 100; x++)
         {
             System.out.println(getName()+":"+x);
             //暂停当前线程，并执行其他线程，不能保证机会均等
             Thread.yield();
         }
     }
 }

23.13  线程控制之守护线程

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

例:

 public class Practice
 {
     public static void main(String[] args)
     {
         MyThread my1 = new MyThread();
         MyThread my2 = new MyThread();

         my1.setName("线程1");
         my2.setName("线程2");

         //将该线程标记为守护线程
         my1.setDaemon(true);
         my2.setDaemon(true);

         my1.start();
         my2.start();

         Thread.currentThread().setName("主线程");
         for (int i = 0; i < 20; i++)
         {
             System.out.println(Thread.currentThread().getName()+":"+i);
         }
     }
 }

23.14  线程控制之中断线程

1.public void interrupt() 中断线程。

2.public final void stop()  停止线程，已过时。该方法具有固有的不安全性。

例:

 public class Practice
 {
     public static void main(String[] args)
     {
         MyThread my = new MyThread();
         my.setName("线程1");
         my.start();
         try
         {
             Thread.sleep(2000);
             //2秒后终止my线程，使用stop()后面的语句都不会执行
             //my.stop();该方法已过时，具有不安全性
             my.interrupt();//后面的语句会执行
         }
         catch (InterruptedException e)
         {
             e.printStackTrace();
         }
     }
 }

23.15  线程生命周期图解

23.16  多线程方式2的思路及代码实现

步骤:

1:自定义类MyRunnable实现Runnable接口

2:重写run()方法

3:创建MyRunnable类的对象

4:创建Thread类的对象，并把3步骤的对象作为构造参数传递

 public class Practice
 {
     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();
     }
 }
 class MyRunnable implements Runnable
 {
     @Override
     public void run()
     {
         for (int i = 0; i < 200; i++)
         {
             System.out.println(Thread.currentThread().getName()+":"+i);
         }
     }
 }

23.17  实现接口方式的好处

1.可以避免由于Java单继承带来的局限性。

2.适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

23.18  继承Thread类的方式卖电影票案例

某电影院电影票共有100张，有3个售票窗口售票，请设计一个程序模拟该电影院售票。

 public class Practice
 {
     public static void main(String[] args)
     {
         sellTicket st1 = new sellTicket();
         sellTicket st2 = new sellTicket();
         sellTicket st3 = new sellTicket();

         st1.setName("窗口1");
         st2.setName("窗口2");
         st3.setName("窗口3");

         st1.start();
         st2.start();
         st3.start();

     }
 }
 class sellTicket extends Thread
 {
     // 定义100张票
     // private int tickets = 100;
     // 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
     private static int tickets = 100;

     @Override
     public void run()
     {
         // 定义100张票
         // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
         // int tickets = 100;

         // 是为了模拟一直有票
         while (true)
         {
             if (tickets > 0)
             {
                 System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
             }
         }
     }
 }

23.19  实现Runnable接口的方式卖电影票案例

 public class Practice
 {
     public static void main(String[] args)
     {
         SellTicket st = new SellTicket();

         new Thread(st, "窗口1").start();
         new Thread(st, "窗口2").start();
         new Thread(st, "窗口3").start();
     }
 }
 class SellTicket implements Runnable
 {
     // 定义100张票
     private int tickets = 100;

     @Override
     public void run()
     {
         while (true)
         {
             if (tickets > 0)
             {
                 System.out.println(Thread.currentThread().getName() + "正在出售第"
                         + (tickets--) + "张票");
             }
         }
     }
 }

23.20  买电影票出现了同票和负数票的原因分析

例:

 class SellTicket implements Runnable
 {
     // 定义100张票
     private int tickets = 100;

     @Override
     public void run()
     {
         while (true)
         {
             //该语句存在安全隐患，如果当票数还剩1张的时候，此时4个线程可能
             //由于CPU的随机切换而通过该语句，当执行下面的语句时就会出现负的
             //票数，同时也可能出现相同的票卖出多次
             if (tickets > 0)
             {
                 try
                 {
                     Thread.sleep(10);
                 }
                 catch (InterruptedException e)
                 {
                     e.printStackTrace();
                 }
                 System.out.println(Thread.currentThread().getName() + "正在出售第"
                         + (tickets--) + "张票");
             }
         }
     }
 }

相同的票出现多次:CPU的一次操作必须是原子性的

出现了负数的票:随机性和延迟导致的

23.21  线程安全问题的产生原因分析

线程安全问题产生的原因:

1.多个线程在操作共享的数据

2.操作共享数据的线程代码有多条

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算,就会导致线程安全问题的产生

23.22  同步代码块的方式解决线程安全问题

思想:把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，其他线程不能来执行。Java提供了:同步机制。

同步代码块:

synchronized(对象)

{需要同步的代码;}

例:

 public class SellTicket implements Runnable
 {
     // 定义100张票
     private int tickets = 100;
     //创建锁对象
     private Object obj = new Object();
     @Override
     public void run()
     {
         while (true)
         {
             //锁对象必须是同一个
             synchronized(obj)
             {
                 if (tickets > 0)
                 {
                     try
                     {
                         Thread.sleep(100);
                     }
                     catch (InterruptedException e)
                     {
                         e.printStackTrace();
                     }
                     System.out.println(Thread.currentThread().getName() + "正在出售第"
                             + (tickets--) + "张票");
                 }
             }
         }
     }
 }

23.23  同步的特点及好处和弊端

同步的前提:多个线程且多个线程使用的是同一个锁对象

同步的好处:同步的出现解决了多线程的安全问题

同步的弊端:当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

23.24  同步代码块的锁及同步方法应用和锁的问题

同步方法就是把同步关键字加到方法上

例:

 //同步方法
     private synchronized void sellTicket()
     {
         if (tickets > 0)
         {
             try
             {
                 Thread.sleep(100);
             }
             catch (InterruptedException e)
             {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName() + "正在出售第"
                     + (tickets--) + "张票");
         }
     }

1.同步代码块的锁对象是任意对象

2.同步函数使用的锁是this

3.静态的同步函数使用的锁是该函数所属的字节码文件对象可以用getClass方法获取，也可以用当前类名.class表示

23.25  以前的线程安全的类回顾

Collections中让集合同步功能

例:

// public static <T> List<T> synchronizedList(List<T> list)
List<String> list1 = new ArrayList<String>();// 线程不安全
List<String> list2 = Collections.synchronizedList(new ArrayList<String>()); // 线程安全