黑马程序员_多线程

------- android培训java培训、期待与您交流！ ----------

进程是一个正在执行的程序,每一个进程执行都有一个执行的顺序,该顺序是一个执行路径,或者叫一个控制单元.进程用于封装线程
线程就是进程中的一个独立的单元,线程在控制着进程的执行,一个进程中至少有一个线程.
Java虚拟机至少两个线程：一个主线程，一个垃圾回收线程 
多线程的出现能够提高效率，多个线程能够同时执行
发现运行结果每一次都不同,因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行,在某一个时刻只能有一个程序在运行,cpu在做着快速的切换,以达到看上去是同事运行的结果,我们可以形象把多线程的运行行为在互相抢夺cpu的执行权
多线程的特性:随机性,谁抢到谁执行,至于执行多长,cpu说的算
为什么要覆盖run方法呢?
Thread类用于描述线程.该类就定义了一个功能,用于存储线程要运行的代码,改存储功能就run方法.也就是说Thread类中的run方法,用于存储线程要运行的代码.
创建线程的第一种方式:继承Thread类.
步骤:1、子类重写父类中的run方法，将线程运行的代码存放在run中
2、建立子类对象的同时线程也被创建
3、通过调用start（）方法开启线程
d.start() 开启线程并执行该线程的run方法
d.run()   仅仅是对象调用方法，线程创建了但是没有执行


创建两个线程和主线程交替运行：

/*
 * 
 * 创建两个线程，和主线程交替运行……
 */
	class Test extends Thread{
		private String name;
		Test(String name){
			this.name = name;
		}
		public void run(){
			for(int i=0; i<60;i++){
				System.out.println(name+"  test run ..."+i);
			}
		}
		
	}
public class ThreadTest extends Thread {


	
	public static void main(String[] args) {
		Test t1 = new Test("one");
		Test t2 = new Test("two");
		t1.start();
		t2.start();
		
		for(int i=0;i<80;i++){
			System.out.println("main........"+i);
		}
	}
}

为什么要覆盖run方法呢？
Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码，将自定义的代码存储在run中。
这样的结果是交替运行的，但是如果t1.run();  t2.run();就会先直行
one 然后直行 two ,这两个所有的线程都直行完了才会执行  main的线程
 线程的几种状态：
 被创建（start()）,运行(sleep(time)),冻结（sleep时间到） 、wait（）
 等待的时候进程没有结束  notify()唤醒  消亡状态（stop()）
 被创建、运行、冻结、消亡
 当线程的run方法结束了，线程没有执行的代码了则这个线程也结束了
 临时状态：具备运行资格但没有执行权
 冻结状态：放弃了执行资格  具有执行资格 被唤醒的时候是到临时状态不是立马回到运行状态
线程都有自己默认的名称可以通过getNama()获取
线程的名称都是从Thread0，Thread1，Thread编号从0开始
可以在构造函数中直接super(name);设置每个线程的名称或者通过setName()来设置
System.out.println(name+"  test run ..."+i);
run()方法中Thread.currentThread()方法和this.name一样的效果

Static Thread currentThread():获取当前线程对象
getName（）：获取线程名称
线程0执行的时候给线程0分配一个内存空间，线程0有自己的run方法，而线程1执行的时候给线程1分配一个内存空间，线程1有自己的run（）方法。
简单的卖票程序，多个窗口买票。

/**
 * 简单的卖票程序，多个窗口同事买票
 * @author yzz
 *
 */
class Ticket extends Thread{
	private static int tick = 100;
	public void run(){
		while(true){
			if(tick>0){
				System.out.println(currentThread()+"......sale:"+tick--);
			}
		}
	}
	
}
public class TicketDemo {
	public static void main(String[] args) {
		Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		Ticket t3 = new Ticket();
		Ticket t4 = new Ticket();
		
		t1.start();
		t1.start();
		t1.start();
		t1.start();


		
	}
}

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

/**
 * 简单的卖票程序，多个窗口同事买票
 * @author yzz
 *
 */
class Ticket implements Runnable{
	private static int tick = 100;
	public void run(){
		while(true){
			if(tick>0){
				System.out.println(Thread.currentThread()+"......sale:"+tick--);
			}
		}
	}
	
}
public class TicketDemo {
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		t1.start();   //这个会调用Thread中的run方法
		t2.start();
		t3.start();
		t4.start();
	}
}

实现方式和继承方式有什么区别呢？
继承Thread：线程代码存放在Thread子类run方法中
实现Runnable，线程代码存在接口的子类的run方法
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
因为有可能一个类本身就继承一个类，所以这时要使用多线程就需要用实现接口的方法
实现方式好处：避免了单继承的局限性，在定义线程时，最好使用实现方式
复写接口的方法时不能抛异常只能try、catch
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。
哪些代码需要同步就看哪些代码操作共享数据
Synchronized（对象）{
需要同步的代码
}
加上同步的代码以后，卖票的程序才能执行，最终的代码：

/**
 * 简单的卖票程序，多个窗口同事买票
 * @author yzz
 *
 */
class Ticket implements Runnable{
	private static int tick = 400;
	Object obj = new Object();
	public void run(){
		while(true){
			synchronized (obj) {
			if(tick>0){
				try {
					Thread.sleep(3);
				} catch (Exception e) {
					// TODO: handle exception
				}
				System.out.println(Thread.currentThread()+"......sale:"+tick--);
			}
			}
		}
	}
	
}
public class TicketDemo {
	public static void main(String[] args) {
		Ticket t = new Ticket();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		t1.start();   //这个会调用Thread中的run方法
		t2.start();
		t3.start();
		t4.start();
	}
}

对象如同锁，持有锁的线程可以再同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。同步可以解决线程的安全问题，同步的前提：
1、 必须要有两个或者两个以上的线程才需要同步。
2、 必须是多个线程使用同一个锁。
3、 必须保证同步中只能有一个线程在运行。
同步的好处和弊端：
好处：解决了多线程的安全问题
弊端：多个线程都需要判断锁，较为消耗资源。
银行存钱的问题：

/**
 * 银行有一个金库，有两个储户分别存300元，每次存100，存3次
 * @author yzz
 *
 */
class Bank{
	private int sum;
	Object  obj = new Object();
	public void add(int n){
		synchronized (obj) {
			
		sum = sum + n;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("sum="+sum);
	}
	}
}
class  Cus implements Runnable{
	private Bank bank = new Bank();


	@Override
	public void run() {
		for(int x=0;x<3;x++){
			bank.add(100);
		}
	}
}
public class BankDemo {
	public static void main(String[] args) {
		Cus cus = new Cus();
		Thread t1 = new Thread(cus);
		Thread t2 = new Thread(cus);
		t1.start();
		t2.start();
	}

同步函数用是哪一个锁呢？
函数需要被对象调用，那么函数都有一个所属对象引用，就是this，所以
同步函数使用的锁是this
同步函数必须要用同一个锁，否则会出现线程安全问题
同步函数用的锁是this 而我么一般写同步代码块的时候用的锁是Object
如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证发现不是this，而是object
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象
synchronized (Ticket.class)；
单例设计模式：
饿汉模式：
class Single{
private static final Single s = new Single();
private Single(){};
public static Single getInstance(){
return s;
}
}
懒汉模式：
class Single{
private static Single s = null;
private Singele(){}
public static Single getInstance(){
if(s==null){
synchronized(Singele.class)
if(s==null)
s = new Single();
return s;
}
}
}
懒汉式会出现线程安全问题，所以需要加锁