多线程

一，进程与线程
进程：具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。换句话说，就是“正在运行的程序”。
程序：是一段静态的代码，是应用程序执行的蓝本。
线程：是进程的一个实体，是CPU调度和分牌的基本单位，是比进程更小的能独立运行的基本单位。线程自己不拥有系统的资源，质拥有一点在运行中的必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他线程共享所拥有的全部资源。


二，线程的状态
创建状态，就绪状态，运行状态，阻塞状态，死亡状态。



三，线程的创建

public class Creat {

	public static void main(String[] args) {
		//继承Tread类创建一个线程
		Thread t1 = new MyThread1();
		t1.start();	
		//启动线程，启动并不是立刻执行run方法，需要抢到CPU后才会执行run方法
		//start只是将线程从创建状态转为就绪状态
		
		//实现Runnable接口创建一个线程
		Thread t2 = new Thread(new MyThread2());
		t2.start();
	}
}

class MyThread1 extends Thread{
	
	public MyThread1(){
		super("线程1");
		//调用父类的无参构造函数设置线程的名字,Runnable接口不行哦！
	}
	
	@Override
	public void run() {
		//通过Thread类方法，获得线程的名字
		//run方法是线程创建时要执行的方法
		System.out.println(this.getName()+"继承Thread类实现创建一个进程");
	}
}

class MyThread2 implements Runnable{
	@Override
	public void run() {
		//Runnable接口为非Thread子类提供了一种激活方式。只有Thread类的run方法，没有其他Thread方法。
		//所以获取该类的名字，要使用Thread.currentThread()(静态方法)获得当前线程，在获取线程的名字。
		System.out.println(Thread.currentThread().getName()+"实现Runnable接口创建一个进程");
	}
}

四，线程常用方法
void setPriority(int newPriority)：设置线程的优先级。优先级：就绪状态的线程按优先级排队，线程调度依据的是优先级基础上的“先到先服务”原则。优先级用整数表示，范围时1-10，默认是5。有三个静态常量可以使用，MAX_PRIORITY：10，表示最高，MIN_PRIORITY：1，表示最低。NORM_PRIORITY：5，表示默认。
static void sleep(long millis) ：让线程睡眠指定的毫秒数。
void join() ：让当前线程等待加入的线程完成，才往下继续执行。
static void yield() ：暂停当前正在执行的线程对象，并执行其他线程。 是不会提高系统的并发性，在实际编程中很少适用。 
void setDaemon(boolean on) ：将该线程标记为守护线程或用户线程。 程序可以分为守护进程和非守护进程。当程序中只有守护进程时，该程序就可以结束运行。


五，线程安全
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。线程安全问题都是由全局变量及静态变量引起的。
synchronized（Object），Object可以是任意的一个对象。也叫监视器。每个对象都有一个标志位，具有0、1两种状态。开始为1，进入同步语句后，变为0，运行完同步代码块后又变回1。

public class Synchronized {

	public static void main(String[] args) {
		Thread t1 = new MyThread4();
		Thread t2 = new MyThread4();
		Thread t3 = new MyThread4();
		t1.start();
		t2.start();
		t3.start();
		// 多个线程，这个打印会乱的，并不是一个线程打印完0-9后，在下一个线程执行
		
		MyThread5 m = new MyThread5();
		Thread t4 = new Thread(m);
		Thread t5 = new Thread(m);
		Thread t6 = new Thread(m);
		t4.start();
		t5.start();
		t6.start();
		//这样就不会乱着打印啦
	}
}

class MyThread4 extends Thread{
	@Override
	public void run() {
		for(int i = 0; i < 10; i++){
			try {
				sleep(1000);	//放慢打印速度
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(this.getName()+"打印："+i);
		}
	}
}

class MyThread5 implements Runnable{
	private Object o = new Object();
	
	// 线程安全的写法一： 使用synchronized 修饰方法，不写 上锁 的对象，相当于用该对象实现 上锁 
	public synchronized void run() {
		for(int i = 0; i < 10; i++){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"打印："+i);	
		}
	}
	
	// 线程安全的写法二：静态代码块  参数为 上锁  的对象，因为一个类中不能存在两个 上锁 的对象，所以注释一个
//	synchronized(o){
//		//执行的代码
//	}
}

六，进程间通信
用到的Object的方法：
void wait() ：导致当前线程等待。 
void notify() ： 唤醒在此对象监视器上等待的单个线程。 
void notifyAll()：唤醒在此对象监视器上等待的所有线程。 
生产者消费者问题

public class ScXf {
	public static void main(String[] args) {
		Car c = new Car();
		Thread s  = new ShengChan(c);
		Thread x = new XiaoFei(c);
		s.start();
		x.start();
		//只会生产一辆车，消费一辆车。不会乱套
	}
}

class Car {
	private boolean isSc = true;
	
	//生产者的方法
	public synchronized void sc(){
		if(isSc){
			System.out.println("生产一辆东风！！");
			isSc = false;
			notifyAll();	//唤醒等待的线程
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	//消费者的方法
	public synchronized void xf(){
		if(!isSc){
			System.out.println("买了一辆东风");
			isSc = true;
			notifyAll();
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class ShengChan extends Thread{
	private Car c = null;
	
	public ShengChan(Car c) {
		super();
		this.c = c;
	}

	@Override
	public void run() {
		while(true){
			c.sc();
		}
	}
}

class XiaoFei extends Thread{
	private Car c = null;
	
	public XiaoFei(Car c) {
		super();
		this.c = c;
	}

	@Override
	public void run() {
		while(true){
			c.xf();
		}
	}
}

七，常见问题
sleep和yield的区别：
sleep使线程睡眠让出CPU，给其他线程运行的机会，不考虑其他现成的优先级，可能会给线程优先级较低的线程一个执行的机会。yield是线程暂停运行，让出CPU，只会给优先级相同或优先级更高的线程一个执行的机会。
sleep睡眠指定时间后，会转到阻塞状态，当yield执行完后，会转到就绪状态。
sleep会抛出InterruptedException异常，而yield方法不会抛出异常。


为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？
通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止，而CPU再运行其它线程。
而如果直接用Run方法，这只是调用一个方法而已，程序中依然只有主线程--这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。


八，面试题
以下多线程对int型变量x的操作，哪几个不需要进行同步（百度笔试题）：  
A. x=y;      B. x++;    C. ++x;    D. x=1;


多线程中栈与堆是公有的还是私有的（阿里巴巴笔试题） 
A：栈公有, 堆私有
B：栈公有，堆公有
C：栈私有, 堆公有
D：栈私有，堆私有

3.（Google面试题）
有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....
D：4 1 2 3 4 1....
请设计程序