多线程

多线程前言：

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

一个进程中至少有一个线程。

Java VM  启动的时候会有两个进程：
1.一个线程负责java程序的执行java.exe。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。
2.另外一个线程负责垃圾回收机制的线程。

线程创建方式：

创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法，
该方法两个作用：启动线程，调用run方法。

创建线程的第二种方式：实现Runable接口
步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

class Ticket implements Runnable
{
	private  int tick = 100;
	public void run()
	{
		while(true)
		{
			if(tick>0)
			{
				System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
			}
		}
	}
}

class  TicketDemo
{
	public static void main(String[] args) 
	{
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);//创建了一个线程；
		Thread t2 = new Thread(t);//创建了一个线程；
		t1.start();
		t2.start();
	}
}

实现方式和继承方式有什么区别呢？
实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。
两种方式区别：
1.继承Thread:线程代码存放Thread子类run方法中。
2.实现Runnable，线程代码存在接口的子类的run方法。

线程的五种状态及其转换

1.新(生)：线程对象已经创建，还没有在其上调用start()方法。
2.可运行:当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。
  a:当start()方法调用时，线程首先进入可运行状态。
  b:在线程运行之后或者从阻塞、等待或睡眠状态回来后也返回到可运行状态。
3.运行：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
4.等待/阻塞/睡眠 ：这是线程有资格运行时它所处的状态。实际上这  三个状态组合为一种，其共同点是：线程仍旧是活 的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行态。
5.死亡: 当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。 如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

线程安全

问题产生的原因：
1.多个线程在操作共享的数据；
2.操作共享数据的线程代码有多条；
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，
就会导致线程安全问题的产生。

解决思路：
将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不可以参与运算的，
必须要当前线程将这些代码执行完毕后，其他线程才可以参与运算。
在Java中，用同步代码块可以解决这个问题，格式为：
synchronized(对象)
{
    需要被同步的代码;
}

同步的好处：解决了线程的安全问题；
同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。
同步的前提：同步中必须有多个线程，并使用同一个锁。

同步函数和同步代码块的区别：
同步函数的锁是固定的this；
同步代码块的锁是任意的对象。
建议使用同步代码块。
静态的同步函数使用的锁是，该函数所属的字节码文件对象，可以用getClass() 方法获取，也可以用 当前 类名.class()获取：对象.getClass();或 Ticket.class;

线程同步小结：
1）、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2）、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。
3）、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
4）、对于同步，要时刻清醒在哪个对象上同步，这是关键。
5）、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
6）、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
7）、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，但是，一旦程序发生死锁，程序将死掉。
即使是线程安全类，也应该特别小心，因为操作的线程是间仍然不一定安全。

线程死锁
    死锁对Java程序来说，是很复杂的，也很难发现问题。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。
    假设read()方法由一个线程启动，write()方法由另外一个线程启动。读线程将拥有resourceA锁，写线程将拥有resourceB锁，两者都坚持等待的话就出现死锁。
 
    实际上，上面这个例子发生死锁的概率很小。因为在代码内的某个点，CPU必须从读线程切换到写线程，所以，死锁基本上不能发生。
    但是，无论代码中发生死锁的概率有多小，一旦发生死锁，程序就死掉。有一些设计方法能帮助避免死锁，包括始终按照预定义的顺序获取锁这一策略。