多线程

多线程：
  首先要理解进程和线程：
  进程查询百度大致可以理解为一段具有独立功能的程序，线程是程序中每个部分的代码，一个进程，拥有多个线程，或者子进程。windows 下exe程序就是一个进程，线程是进程在相同时间分个每个客户单独运行的一段相同程序代码，说的有点抽象，就想本人打英雄联盟吧！可能10个人进入游戏开始，算是一个进程吧，我们每个人完的时候，相互不影响（程序相互不影响），可以自己玩自己的，释放技能。还是先来看用法吧！（重点）多线程主要是用于同时执行多个执行流的，开始有三种方式第一种继承Thread 第二种实现Callable 接口，要实现一个futureTask 类 有一个返回类型 想要马上要调用get
多线程具有五中基本状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就     绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

常见的方法：start();开始执行线程,有新建状态到就绪状态。
            stop();终止线程，有运行状态到就绪状态。
            sleep(long),sleep(long,Interger)根据时间暂停线程,有运行状态到睡眠状态。        suspend(),挂起执行，运行状态到阻塞状态。
            resume()恢复执行，阻塞状态到就绪状态
            yield() 暂停当前线程 执行其他的线程，执行完后再执行当前线程
            wait()是让一个线程等待，执行等其他线程执行
            notify() 唤醒当前正在等待的线程
            join() 作用：将某一个子线程加入到当前线程。主线程结束，无论子线程有没有运行完，都结束
            interrupt()；终止当前线程
            setPriority()；设置线程取值方法，在API 中有一些自定义的常量
            MAX_PRIORITY
            线程可以具有的最高优先级。
            MIN_PRIORITY
            线程可以具有的最低优先级。
            NORM_PRIORITY
            分配给线程的默认优先级。

线程同步两种方式：
        

 * 线程安全的两种方式 存钱
           * 方式1：synchronized 锁住线程
           * @return 存钱 deposit(double money)
           */
           public /*synchronized*/ void deposit(double money){
               balance += money;
               try {
                   Thread. sleep(1);
              } catch (InterruptedException e ) {
                    e.printStackTrace();
              }
          }


          /**
           *
           * @param money 取钱
           */
           public void withdraw(double money){
               /**
               * 方式二：
               */
               synchronized (this ) {
                    balance -= money;
                    try {
                        Thread. sleep(1);
                   } catch (InterruptedException e ) {
                         e.printStackTrace();
                   }
              }
              
          }

容易造成死锁


entity：

package javaTest.thread;

import java.util.concurrent.Callable;

public class Call implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		for(int i=1;i<=11;i++){
			System.out.println("剑圣偷"+i+"塔");
			/**
			 * 调用静态方法模拟偷塔时间
			 */
			Thread.sleep(1000);
		}
		return 11;
	}
	
}

package javaTest.thread;

public class Gailun implements Runnable{
private String name;
	public Gailun() {
	super();
}
	public Gailun(String name) {
	super();
	this.name = name;
}
	@Override
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println(name+"上路拿人头");
		}	
	}	
}

package javaTest.thread;

public class Hanbing extends Thread {

	private String name;
	public Hanbing() {
		super();
	}
	public Hanbing(String name) {
		super();
		this.name = name;
	}
	@Override
	public void run() {
		Integer i =0;
		while(i<=100){
			System.out.println(name+"寒冰下路补兵");
			i++;
		}
	}
}

package javaTest.thread;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Testthread {
	
	public static void main(String[] args) {
		/**
		 * 启动线程的三种方式
		 * 方式1：
		 */
		Hanbing hanbing = new Hanbing("寒冰");
		/**
		 * 启动线程方式2
		 */
	    Gailun gailun = new Gailun("gailun");
	    Thread thread1 = new Thread(gailun);
	    /**
	     * 启动线程方式3：
	     */
		Call call = new Call();
		FutureTask<Integer> futureTask = new FutureTask<Integer>(call);
		Thread thread2 = new Thread(futureTask);
		/**
		 * 启动三个线程
		 */
		thread2.start();
		hanbing.start();
		thread1.start();
		try {
			/**
			 * 如果想得到一个结果
			 */
			Integer a = futureTask.get();
			System.out.println(a);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}	
	}
}

死锁：1,当你用到锁(synchronized)的时候.
2,多个线程同时锁住对方需要的资源时候。解决办法：就是同步说，上面有代码。不知道理解的对不对。还希望大家多多指正。