黑马程序员-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培训、期待与您交流！ ----------------------