多线程总结（一）-概念，场景，创建，使用，基本方法，基本状态，线程不安全的原理，以及关键字 Synchronized 的使用

多线程总结（一）-概念，场景，创建，使用，基本方法，基本状态，线程不安全的原理，以及关键字 Synchronized 的使用

一.概念（场景）
首先我们在学习程序与进程的时候知道，最小的执行单位是线程。

个人认为多线程理解的最好概念就是，一个线程就是一个执行路径（path）,多个线程就是多个路径。
举个最简单的也最ok的例子，电影院买票，100张票，如果只有一个执行路径（一个买票窗口）那么会非常慢，这时候可以使用多个执行路径（多个线程也就是多个买票窗口），来提高电影院的工作的效率

二.线程的创建
线程的创建一共有5种方式，本次只复习到了3种
第一种方式，继承继承Thread类创建线程类，重写run（）【这个run就是该线程需要完成的内容】

package com.thread;
 
public class FirstThreadTest extends Thread{
	int i = 0;
	//重写run方法，run方法的方法体就是现场执行体
	public void run()
	{
		for(;i<100;i++){
		System.out.println(getName()+"  "+i);	
		}
	}
	public static void main(String[] args)
	{
		for(int i = 0;i< 100;i++)
		{
			System.out.println(Thread.currentThread().getName()+"  : "+i);
			if(i==20)
			{
				new FirstThreadTest().start();
				new FirstThreadTest().start();
			}
		}
	}
 
}

第二种方法，实现通过Runnable接口创建线程类

package com.thread;
 
public class RunnableThreadTest implements Runnable
{
 
	private int i;
	public void run()
	{
		for(i = 0;i <100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
	public static void main(String[] args)
	{
		for(int i = 0;i < 100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
			if(i==20)
			{
				RunnableThreadTest rtt = new RunnableThreadTest();
				new Thread(rtt,"新线程1").start();
				new Thread(rtt,"新线程2").start();
			}
		}
 
	}
 
}

di第三种，通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

package com.thread;
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class CallableThreadTest implements Callable<Integer>
{
 
	public static void main(String[] args)
	{
		CallableThreadTest ctt = new CallableThreadTest();
		FutureTask<Integer> ft = new FutureTask<>(ctt);
		for(int i = 0;i < 100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
			if(i==20)
			{
				new Thread(ft,"有返回值的线程").start();
			}
		}
		try
		{
			System.out.println("子线程的返回值："+ft.get());
		} catch (InterruptedException e)
		{
			e.printStackTrace();
		} catch (ExecutionException e)
		{
			e.printStackTrace();
		}
 
	}
 
	@Override
	public Integer call() throws Exception
	{
		int i = 0;
		for(;i<100;i++)
		{
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		return i;
	}
 
}

三.调用，线程的调用切记用start（）而不是run（），方法new Theard.run()虽然会执行方法体内容，但是也就是单纯的执行一次run方法，不会使用新的线程，也就是系统里面任然只有一个main线程在工作，run（）里面的方法体与mian正常顺序执行

总结： 调用 start() 方法方可启动线程并使线程进入就绪状态，直接执行 run() 方法的话不会以多线程的方式执行。

四.线程状态，如下图（非常详细）

线程状态分为new，waiting，time-waiting，blocked，ready，terminated6种状态
这里重点说一下wait与sleep方法，wait方法如果指定时间的话是让线程从就绪状态进入到超市等待状态，如果不知道则进入等待状态
二者区别两者最主要的区别在于：sleep() 方法没有释放锁，而 wait() 方法释放了锁 sleep单纯去睡觉但是并没有释放资源，这也是为什么sleep可以在任意情况下使用，而wait只能在锁下使用
当然二者也 有相同之处，则是都可以暂停线程的执行

五.线程不安全的原理
前面说了线程的理解可以当成电影院买票，那么就从电影院买票上面来分析线程不安全的问题，首先上代码

public class MySynchronizedThread implements  Runnable {
    private  int count=50;

    @Override
    public  void run() {
        while(true){
            buy();
        }

    }
    public synchronized  void  buy(){
        if(count>0){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":  抢到第"+count--+"张,"+System.currentTimeMillis());
        }
     }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread,"关羽");
        Thread thread1 = new Thread(myThread,"张飞");
        Thread thread2 = new Thread(myThread,"刘备");
        thread.start();
        thread1.start();
        thread2.start();
    }
}

因为有三个人卖票，那么有可能他们卖的同一张票，因为可以在刘备进入if（count>0）是（假设这是在卖第10张票），那么现在cpu给了关羽这个线程，那么打印语句变成了关羽正在卖第40张票，结束之后回到刘备这个线程，因为刘备还在if里面所以无需判断继续完成接下来的打印语句操作，也就是刘备正在卖第40张票，所以对应共享资源的多线程访问会存在线程不安全问题，那么这个时候就需要上锁
synchronized，同步代码块，锁机制（jdk1.5之后的lock），都是解决方法