多线程的一点小事

以前在学Java的时候，没有仔细研究过多线程，后来在工作中也很少碰到，现在再捡起来学习一下。什么是多线程，经常和进程比较容易混淆，当程序启动以后，就会产生一个进程，而一个进程下面会有多个线程同步或者异步执行。

实现多线程的两种方式，在Java中可以通过实现Runable接口和继承Thread类来实现。

继承方式：

public class MyThread  {
	public static void main(String[] args) {
		TestThread testThread=new TestThread("test thread");
		testThread.start();		
		for (int i = 0; i < 100; i++) {
			System.out.println("main"+i);
		}
	}
}
class TestThread extends Thread{
	public TestThread(String name){
		super(name);
	}
	@Override
	public void run() {
		//每一个成员变量都有一个存储空间
		int index=0;
		for (; index < 10; index++) {
			System.out.println(this.getName()+index);
		}
	}
}

1.继承thread
2.覆盖run方法,run方法中的代码就是基于多线程
3.创建这个类的对象 调用start方法启动线程

接口方式：

public static void main(String[] args) {
		
		ThredInterface interface1=new ThredInterface();
		try {
			interface1.begin();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	class Mythread2 implements Runnable{
		int index=0;
		private boolean flag=true;
		@Override
		public void run() {
			
			//需要多线程运行的程序
			//共享成员变量,所有线程都来改
			for (index=0; index < 2000; index++) {
				if(!flag)break;
				System.out.println(Thread.currentThread().getName()+index);
			}
		}
		
		public void stopThread(){
			//释放资源
			
			flag=false;
		}
	}

1.实现runable接口
2.覆盖run方法,run方法中的代码就是基于多线程
3.由于实现runable接口没有start方法，所以将实现runable接口的类放置在一个Thread中运行

区别：
成员变量，继承的方式，是每个线程的成员变量都有一个存储空间，而接口的方式是所有线程共享一个成员变量，交替执行。

开发中一般使用接口方式调用，因为如果使用了继承的方式，那么该类就不能继承其他类了，而实现接口，可以实现多个接口。

常用方法：

为线程设置名称

thread中构造方法的第一个参数是实现runable接口的类，第二个参数就是线程名称
 public Thread(Runnable target, String name) {
init(null, target, name, 0);
    }

获取线程名称：Thread.currentThread().getName()
线程调度：
th.join();// 一直不轮换，当前线程必须走完
th.yield();// 暂时等待，不参与这一次的抢占-->到runable状态

但是线程的调度不能只通过这两个方法来控制
sleep休眠
stop停止线程,不建议使用 不安全，自己写一个停止的方法释放资源,定义一个stop线程的方法释放资源。

线程的状态：Runable runing blocked

线程同步：使用synchronized,可以在方法声明的时候标记，也可以使用一个key来作为线程同步块

synchronized (this) {
			Mythread2 m=new Mythread2();
			Thread th=new Thread(m,"线程1");
			//Thread th2=new Thread(m,"线程2");
			th.start();
			//th2.start();
			while (true) {
				if (m.index==1000) {
					System.out.println("tingzhi");
					th.stop(); //不安全
					m.stopThread();
					break;
				}
			}
		}

同步会丢失效率，后面的所有线程都要等待,同步的原子性放小，提高效率,而什么时候用同步，如果多个线程需要修改同一个变量。

死锁：同步的嵌套的时候，线程之间相互等待
解决：同步的原子性放大,会降低效率，兼顾同步和效率
死锁程序：

public static void main(String[] args) {
		new TestLock().run();
	}
	
	public void run(){
		LockThread lockThread=new LockThread();
		new Thread(lockThread,"线程一").start();
		new Thread(lockThread,"线程二").start();
	}
	class LockThread implements Runnable{

		private Object k1=new Object();
		private Object k2=new Object();
		private boolean flag=true;
		@Override
		public void run() {
			if (flag) {
				flag=false;
				synchronized (k1) {
					System.out.println(Thread.currentThread().getName()+"k1");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (k2) {
						System.out.println(Thread.currentThread().getName()+"k2");
					}
				}
				
			}else{
				flag=true;
				synchronized (k2) {
					System.out.println(Thread.currentThread().getName()+"k2...");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					synchronized (k1) {
						System.out.println(Thread.currentThread().getName()+"k1");
					}
				}							
			}
			
		}
		
	}