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