Java多线程1——概述

一、概念

1.进程：是一个正在执行中的程序，每一个进程执行都有一个而执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

2.线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

3.java虚拟机启动的时候会有一个进程java.exe，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

二、创建线程

   方法一：继承Thread类
    步骤：1.定义类继承Thread。
	  2.重写Thread类中的run方法
		目的：存储自定的代码，让线程去运行。
	  3.调用线程的start方法（该方法两个作用：启动线程，调用run方法 
Demo1：继承Thread类创建线程
class Demo extends Thread {
	Demo(String name) {
		super(name);
	}
	
	public void run() {
		for(int x=0; x<60; x++) {
			System.out.println(Thread.currentThread().getName() + "run-----" + x);
		}
	}
}
public class ThreadDemo {
	public static void main(String[] args) {
		Demo d1 = new Demo("one---");
		Demo d2 = new Demo("two---");
		d1.start();
		d2.start();
		
		for(int x=0; x<60; x++) {
			System.out.println("Hello World---" + x);
		}
	}
}

P.S   1.线程的名字可以调用父类的构造函数，直接定义的时候就传进去
       2.获取当前线程：Thread.currentThread()
      3.获取线程名字：getName()

方法二：实现Runnable接口

	步骤：  1.定义类实现Runnable接口
		2.重写Runnable接口中的run方法
		3.通过Thread类建立线程对象
		4.将Runnable接口的子类对象最为实际参数传递给Thread类的构造函数
		5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
P.S    由于Java是只支持单继承，当某些类已经有父类时，就不能再继承Thread类，这时应该使用Runnable接口实现多线程，这种方法也是比较常用的方法。

Dmeo2：实现Runnable接口创建线程

class TickDemo implements Runnable {
	private int tick = 100;
	public void run() {
		while(true) {
			if(tick > 0) {
				System.out.println(Thread.currentThread().getName() + "sale--" + tick--);
			}
		}
	}
}
public class Ticket {
	public static void main(String[] args) {
		TickDemo t = new TickDemo();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();	
	}
}

    运行一下，能够把100张票顺利卖完，但是这个程序隐含了一个安全问题。假如有这种情况，当票只剩一张的时候，t1线程判断进去判断if语句，票大于0，所以进入，但是进去之后在输出语句执行之前，t1线程的执行权被t2线程给抢走了，这时t2线程也判断if语句，也成功进入了，那么当t1，t2都执行完后将会卖掉101张票，这就出问题了。要模拟这种情况我们可以在输出语句执行之前加个sleep语句，手动让先进来的线程放弃执行权，让另一个线程进入。
    经过分析我们得出这样的结论，产生这个问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
    Java对多线程安全问题提供了专业的解决方式，其中一种就是同步代码块：
    synchronized(对象){
	需要被同步的代码
    }
Demo3：synchronized同步代码块

class TickDemo implements Runnable {
	private int tick = 100;
	Object obj = new Object();
	public void run() {
		while(true) {
			synchronized(obj){
				if(tick > 0) {
					System.out.println(Thread.currentThread().getName() + "sale--" + tick--);
				}
			}
		}
	}
}
public class Ticket {
	public static void main(String[] args) {
		TickDemo t = new TickDemo();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
		
	}
}

    这段代码运行完票可以正常卖光，synchronized(对象)这里面的对象可以是任何对象，为了方便这里直接new了一个object对象，这个对象如同一把锁，当有一个线程进入synchronized()后，这个锁就锁上了，其他线程想进来也进不来，只有当第一个线程执行完synchronized这块代码后，锁才会重新打开，后面的线程就可以进入了，当然一个线程进入后，又会锁上，这样就保证了线程的安全性。不过安全的东西总要付出代价的，就是速度会变慢，因为每次执行代码都要判断是否可以进入。
    synchronized不仅可以用于代码块，也可以用在函数上
Demo4：synchronized同步函数

class TickDemo implements Runnable {
	private int tick = 100;
//	Object obj = new Object();
	public void run() {
		while(true) {
			show();
		}
	}
	public synchronized void show() {
		if(tick > 0) {
			System.out.println(Thread.currentThread().getName() + "sale--" + tick--);
		}
	}
}
public class Ticket {
	public static void main(String[] args) {
		TickDemo t = new TickDemo();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		t2.start();
		
	}
}

    这段代码也可以运行成功，但是之前我们同步代码块的时候，synchronized可以用对象作为锁，那么同步函数又是什么作为这个锁呢?答案是this，就是调用这个函数的对象。我们可以写个程序来验证一下。
Demo5：验证同步函数用的是this锁

class TickDemo implements Runnable {
	private int tick = 1000;
	Object obj = new Object();
	boolean flag = true;
	public void run() {
		if(flag) {
			while(true) {
				synchronized(this) {
					if(tick > 0) {
						try {Thread.sleep(10);} catch (InterruptedException e) {}
						System.out.println(Thread.currentThread().getName() + "sale--" + tick--);
					}
				}
			}
		}
		else
			while(true) 
				show();
	}
	public synchronized void show() {
		if(tick > 0) {
			try {Thread.sleep(10);} catch (InterruptedException e) {}
			System.out.println(Thread.currentThread().getName() + "sale--" + tick--);
		}
	}
}
public class Ticket {
	public static void main(String[] args) {
		TickDemo t = new TickDemo();
		
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		t1.start();
		try {Thread.sleep(10);} catch (InterruptedException e) {}
		t.flag = false;
		t2.start();
		
	}
}

    这段代码思路是：让t1进入同步代码块，让t2进入同步函数，我们把锁设定为this，如果他们同步成功，说明的确用的是this锁。运行结果是成功的，是this锁，如果将代码块的对象改成obj，那么就会出错。
    同步函数如果用static修饰，那么锁就不是this，因为初始化静态函数的时候还没有对象。因此静态同步方法使用的锁是该方法所在类的字节码文件对象，也就是类名.class。如果想验证可以将上面的同步函数用static修饰，然后在同步代码块传入Ticket.class，一样可以运行成功。

	多线程还有可能会出现死锁，比如在同步中嵌套了同步。
Demo6：死锁

class Test implements Runnable {
	private boolean flag;
	Test(boolean flag) {
		this.flag = flag;
	}

	public void run() {
		if(flag) {
			while(true) {
				synchronized(MyLock.locka) {
					System.out.println(Thread.currentThread().getName()+"...if locka ");
					synchronized(MyLock.lockb) {
						System.out.println(Thread.currentThread().getName()+"..if lockb");					
					}
				}
			}
		}
		else {
			while(true) {
				synchronized(MyLock.lockb) {
					System.out.println(Thread.currentThread().getName()+"..else lockb");
					synchronized(MyLock.locka) {
						System.out.println(Thread.currentThread().getName()+".....else locka");
					}
				}
			}
		}
	}
}

class MyLock {
	static Object locka = new Object();
	static Object lockb = new Object();
}

class  DeadLockTest {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

     上面的程序有可能会出现这种情况：当t1线程进入if之后，拿到了a锁，还未执行b锁那，此时cpu执行权被t2拿到，t2拿到了b锁，那么t1，t2两个线程就会僵持，程序就死掉了。编程时应避免这种情况的发生。

Dmeo7：匿名内部类创建线程

class ThreadTest {
	public static void main(String[] args) {
		
		new Thread(){
			public void run(){
				for(int x=0; x<100; x++){
					System.out.println(Thread.currentThread().getName()+"....."+x);
				}
			}
		}.start();
		

		Runnable r  = new Runnable(){
			public void run(){
				for(int x=0; x<100; x++){
					System.out.println(Thread.currentThread().getName()+"....."+x);
				}
			}
		};
		new Thread(r).start();

		for(int x=0; x<100; x++)
		{
			System.out.println(Thread.currentThread().getName()+"....."+x);
		}

	}
}