多线程

多线程

1.了解

1.首先了解一下什么是进程：
	进程我理解的就是一个能够独立运行的程序就是一个进程。所有的进程都是由操作系统分配给CPU执行，某个时间点只能执行一个进程，由于CPU执行的速度很快，所以就会感觉到多进程执行
2.进程与线程的关系：
	一个进程至少有两个或两个以上的线程   main线程，JVM的GC 垃圾回收机制
	例如：电脑管家 （进程） 里面的垃圾清理（线程）、闪电杀毒（线程）。。。。

2.线程

1.特征：
	1.每个线程都是独立的，可以并发执行
	2.有一定的动态性
	3.有一定的不可把控性
2.线程创建的两种方式：
	1.继承Thread类并重写run()方法，在run()方法中写入要实现多线程的代码
		创建自定义线程类对象，调用start方法，开启线程
	2.实现implements Runnable接口，重写run()方法写入要实现多线程的代码
		创建Thread类对象，把遵从Runnable 接口的实现类对象，作为Thread类构造方法的参数，使用Thread类中的start() 方法开启线程
3.以上两种方式更推荐使用第二种方式，原因：
	1.java有一种特征就是单继承，也就是说你一个类一旦继承Thread类就没有办法继承其他的类，有一定的局限性
	2.在处理共享资源方面，第二种方式处理的会更好，能够很好的把线程同程序代码和数据有效的分离
4.后台线程（守护线程）：
	如果一个进程只有后台线程在运行，这个进程就会关闭。
	某个线程在【启动之前】调用Thread类的setDaemon(true)方法，就会变成后台线程，主要是用于错误log日志，还有就是软件更新/内存回收。。。
	

3.线程中常用的方法

// 设置线程的优先级Thread类构造方法 Constructor
	Thread(); // 没有参数的构造方法
	Thread(Runnable target); // 这里需要使用一个Runnable接口的实现类对象，作为当前Thread类构造方法参数，该对象，也就是Thread要执行的线程
	Thread(Runnable target, String name); // Runnable接口实现类作为线程参数，然后再给线程起一个名字
成员方法 Method
	void setName(String name); // 设置线程的名字
	String getName(); // 获取线程的名字
	/*
	线程优先级
		优先级取值范围: 1 - 10 1 最低， 10 最大
		但是不保证优先级高的线程一定执行，也不保证优先级低的线程一定不执行。
		这里优先级有且只是执行的概率大小，默认线程的优先级都是5
	*/
	void setPriorty(int newPriority); // 设置线程的优先级
	int getPriority(); // 获取线程的优先级
	
	static Thread currentThread(); // 返回当前方法所在线程代码块的线程对象。
	static void sleep(int ms); // 当前方法在哪一个线程代码块中，哪一个线程暂停指定的毫秒数。	
	void yield();//线程让步,当Thread.yield();时线程就会做出让步处理，这里是直接回到就绪状态
	void join();//当线程调用这个方法时，此线程就会插入到包含这段代码中的线程去，插入线程执行完毕后才会，运行被插入的线程运行。

4.线程同步

1.同步代码块
	synchronized (/*锁对象*/) {
		//需要同步的代码块，要上锁的代码块
	}
注意：
	1. 首先锁对象，必须是一个【对象】
	2. 线程的锁对象是唯一的！！！同一个对象！！！，不能放在run()方法中创建这个锁对象
	3. 任何对象都可以作为锁对象
	4. 使用同步代码块加锁的代码，越少越好，提高效率
	5. Thread.sleep(int ms) 该方法不会开启锁对象！！
2.同步方法
	synchronized 返回值 方法名（[参数]）{}
	同步方法也有自己的锁，它的锁就是调用这个方法的对象
	静态同步方法没有类对象，它的锁就是这个静态同步方法所在的类对象
3.弊端：
	消耗资源，效率较低，每次都要判断锁对象
4.死锁问题，不做过多解释，没什么用。
	至少两个线程，两个锁对象，互相持有

5.多线程通讯

/*这里使用到两个重要的方法：
	Object类的：
		void wait();使当前线程进入阻塞状态，只有调用notify() 或者 notifyAll(),这个线程才会再次被调度
		void notify();唤醒同步锁wait()等待的第一个线程
		void notifyAll();唤醒同步锁wait()等待的所有线程
*/
class Car {
	private String name;
	private int pic;
	private boolean falg;
	public Car() {
		super();
	}
	public Car(String name, int pic, boolean falg) {
		super();
		this.name = name;
		this.pic = pic;
		this.falg = falg;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPic() {
		return pic;
	}
	public void setPic(int pic) {
		this.pic = pic;
	}
	public boolean isFalg() {
		return falg;
	}
	public void setFalg(boolean falg) {
		this.falg = falg;
	}
	@Override
	public String toString() {
		return "Car [name=" + name + ", pic=" + pic + ", falg=" + falg + "]";
	}

}
class Factory implements Runnable{
	private Car c;
	int count = 0;

	public Factory(Car c) {
		super();
		this.c = c;
	}

	@Override
	public void run() {
		synchronized(c) {
			while(count < 50){
				if(c.isFalg()) {
					System.out.println("正在生产" + c.getName() + ":" + c.getPic());
					c.notify();
					count++;
					c.setFalg(false);
				} else {
					try {
						c.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}
}
class Customer implements Runnable{
	private Car c;

	public Customer(Car c) {
		super();
		this.c = c;
	}

	@Override
	public void run() {
		synchronized (c) {
			int count = 0;
			while (count < 50) {
				if(!c.isFalg()) {
					System.out.println("消费者购买了" + c.getName());
					
					c.notify();
					count++;
					c.setFalg(true);
				} else {
					try {
						c.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
	}
}
public class Demo5 {

	public static void main(String[] args) {
		Car c = new Car("奥迪A4l", 320000, true);
		Thread t1 = new Thread(new Factory(c));
		Thread t2 = new Thread(new Customer(c));
		t1.start();
		t2.start();
	}

}

6.线程的声明周期