黑马程序员-Java基础-多线程总结

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

       进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
       线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。

     一个进程中至少有一个线程。Java虚拟机启动时，会有一个进程 java.exe.该进程中至少会有一个负责Java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。Java提供了对线程这类事物的描述，就是Thread类。

     线程的五种状态：被创建、运行、冻结（睡眠和等待）、消亡，临时（阻塞）。 

    线程关系图如下：

    

  

    创建线程的第一种方式：实现Tread类。
    步骤：
    1、定义类Thread
    2、复写Thread类中的run（）方法。
          目的：将自定义的代码存储在run方法中，让线程运行。
     3、调用Thread类中的start()方法,该方法有两个作用，启动线程，调用run()方法。
      运行结果每一次都不同，因为多个线程都获取CPU的执行权，CPU执行到谁，谁就运行。
     明确一点：在某一个时刻，只能有一个程序在运行，（多核除外），CPU在做着快速切换，以达到看上去是同时运行的结果。我们可以形象的把多线程运行行为在互相抢夺CPU的执行权。这就是多线程的一个特性：随机性，谁抢到谁执行，至于        执行多长，CPU说了算。

     为什么要覆盖run方法呢？
    Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。也就是Thread类中的run方法用于存储线程要运行的代码。

 创建多线程的方式二：实现Runnable接口
 * 步骤：
 * 1、定义类实现Runnable接口
 * 2、覆盖Runnable接口中的run方法，
 *   将线程要运行的代码存放在run方法中
 * 3、通过Thread类建立线程对象。
 * 4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
 *    自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，必须明确该run方法所属对象。
 * 5、调用Thread类的start方法 开启线程并调用Runnable接口子类的Run方法。
 * 
 * 定义线程的两种方式：继承Thread类和实现Runnable接口有什么区别呢？
 * 实现方式好处：避免了单继承的局限性，在定义线程时，建议使用实现方式。
 * 两种方式的区别：
 * 继承Thread类：线程代码存放在Thread子类run方法中。
 * 实现Runnable接口：线程代码存放在接口的子类的run方法中。

 多线程出现了安全问题。
 * 问题原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致了共享数据的错误。
 * 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
 * Java对于多线程的安全问题，提供了专业的解决方式。

 * 解决多线程安全问题的方式有两种：
 * 1、同步代码块。
 * 2、同步方法。
 * 
 * 同步代码块：
 * synchronized(对象)
 * {
 *   需要被同步的代码;
 * }
 * 需要被同步的代码,是指操作同步数据的语句。
 * 对象如同锁，持有锁的线程可以在同步中执行，没有持有锁 的线程即使获取CPU的执行权，也进不去，因为没有获得锁。
 * 举例：火车上的卫生间。
 * 
 * 同步的前提：
 * 1、必须要有两个或者两个以上的线程。
 * 2、必须是多个线程使用同一个锁。
 * 
 * 必须保证 同步中只能有一个线程在运行。
 * 
 * 好处：解决了多线程的安全问题。
 * 弊端：多个线程都需要判断锁，较为消耗资源。

 * 使用同步方法解决多线程安全性问题
 * 同步函数使用的是哪一个锁呢？
 * 函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
 * 所以同步函数使用的锁就是this。

 * 如果同步函数被静态修饰后。使用的锁是什么呢？
 * 通过验证不再是this，因为静态方法中也不可以定义this。
 * 静态进内存时，内存中没有本类对象， 但是一定有该类对象对应的字节码文件对象，
 * 类名.class 该对象的类型是class
 * 静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class。

继承Thread类创建线程举例：

package com.itheima.day11;/** * Java提供了对线程这类事物的描述，就是Thread类。 * 创建线程的第一种方式：实现Tread类。 * 步骤： * 1、定义类Thread * 2、复写Thread类中的run（）方法。 *    目的：将自定义的代码存储在run方法中，让线程运行。 * 3、调用Thread类中的start()方法,该方法有两个作用，启动线程，调用run()方法。 *  * 运行结果每一次都不同，因为多个线程都获取CPU的执行权，CPU执行到谁，谁就运行。 * 明确一点：在某一个时刻，只能有一个程序在运行，（多核除外）， * CPU在做着快速切换，以达到看上去是同时运行的结果。我们可以形象的把多线程运行行为在互相抢夺CPU的执行权。 * 这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，CPU说了算。 *  */public class ThreadDemo {public static void main(String[] args) {TDemo1 t = new TDemo1();//创建一个线程//t.run();仅仅是对象调用方法，而线程创建了，并没有运行。//执行t.run();代码时运行结果是执行demo run 50次，然后在执行hello world 50次t.start();//开启线程并执行该线程的run方法//运行结果是demo run 和hello world交替执行for(int i=0; i<50; i++){System.out.println("hello world! ---"+i);}}}class TDemo1 extends Thread{    public void run()    {    for(int i=0; i<50; i++){System.out.println("demo run --"+i);}    }}

实现Runnable接口创建线程举例：

package com.itheima.day11;/** * 创建多线程的方式二：实现Runnable接口 * 步骤： * 1、定义类实现Runnable接口 * 2、覆盖Runnable接口中的run方法， *   将线程要运行的代码存放在run方法中 * 3、通过Thread类建立线程对象。 * 4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。 *    自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，必须明确该run方法所属对象。 * 5、调用Thread类的start方法 开启线程并调用Runnable接口子类的Run方法。 */class Demo4 implements Runnable{   private  static int tick = 100;//票是全局变量，而且四个线程对象共用100张票，必须静态。   public void run()   {   while(true)   {   if(tick>0)   {   System.out.println(Thread.currentThread().getName()+"---sale："+tick--);   }   }   }}public class RunnableDemo1 {public static void main(String[] args) {Demo4 t = new Demo4();            Thread t1 = new Thread(t);            Thread t2 = new Thread(t);            Thread t3 = new Thread(t);            Thread t4 = new Thread(t);            t1.start();            t2.start();            t3.start();            t4.start();} }

解决多线程安全性问题举例：

package blog.Javase.Thread;/** *需求： * 使用两个线程来卖票： * 一个在同步代码块中， * 一个在同步方法中。 * 都在执行卖票动作。二者交替运行。 *  *  * 使用同步方法解决多线程安全性问题 * 同步函数使用的是哪一个锁呢？ * 函数需要被对象调用，那么函数都有一个所属对象引用，就是this。 * 所以同步函数使用的锁就是this。 *  * 如果同步函数被静态修饰后。使用的锁是什么呢？ * 通过验证不再是this，因为静态方法中也不可以定义this。 * 静态进内存时，内存中没有本类对象， 但是一定有该类对象对应的字节码文件对象， * 类名.class 该对象的类型是class * 静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class */class Ticket implements Runnable{   private  int ticket = 100;   Object Object = new Object();   boolean flag= true;   public  void run()   {   if(flag)   {   while(true)   {   synchronized(this)//object锁synchronized(Object),为了保证同一个锁，改为this   {if (ticket > 0) {try{Thread.sleep(10);}catch(Exception e){}System.out.println(Thread.currentThread().getName()+ "-code：" + ticket--);}    }    }   }   else     while(true)      show();//相当于this.show();   }   public synchronized void show()//this锁   {   if(ticket>0)   {   try{Thread.sleep(10);}catch(Exception e){}   System.out.println(Thread.currentThread().getName()+"---show---"+ticket--);   }   }   }public class TicketDemo3 {public static void main(String[] args) {Ticket t = new Ticket();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        t1.start();        try{Thread.sleep(10);}catch(Exception e){}        t.flag = false;        t2.start();/*      Thread t3 = new Thread(t);        Thread t4 = new Thread(t);        t3.start();        t4.start();*/}}

多线程死锁举例：

package blog.Javase.Thread;//死锁举例public class DeadLockDemo {public static void main(String[] args) {Thread t1 = new Thread(new Test(true));Thread t2 = new Thread(new Test(false));t1.start();t2.start();}}class MyLock{static Object locka = new Object();static Object lockb = new Object();}class Test implements Runnable{private boolean flag;Test(boolean flag){this.flag = flag;}public void run(){if(flag){while(true){synchronized(MyLock.locka)//拿到locka锁，需要lockb锁{System.out.println("if locka");synchronized(MyLock.lockb){System.out.println("if lockb ");}}}}else{while(true){synchronized(MyLock.lockb)//拿到lockb锁需要locka锁{System.out.println("else lockb ");synchronized(MyLock.locka){System.out.println("else locka ");}}}}}}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------