本文将主要介绍Java中多线程的使用方法、线程同步、线程数据传递、线程安全问题。首先先了解一下进程和线程和程序的区别。

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

线程的创建与启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread
类来体现。
Thread类的特性：
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常
把run()方法的主体称为线程体。
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()。

创建线程的四种方式
方式一：继承Thread类

1. 定义子类继承Thread类。
2. 子类中重写Thread类中的run方法。
3. 创建Thread子类对象，即创建了线程对象。
4. 调用线程对象start方法：启动线程，调用run方法。

注意：

1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
3. 想要启动多线程，必须调用start方法。
4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

方式二：实现Runnable接口

1. 定义子类，实现Runnable接口。
2. 子类中重写Runnable接口中的run方法。
3. 通过Thread类含参构造器创建线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

创建线程的方式三：实现Callable接口

• 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
• 1.call()可以有返回值的。
• 2.call()可以抛出异常，被外面的操作捕获，获取异常的信息。
• 3.Callable支持泛型。

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call()方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i <=100; i++) {
            if (i%2==0){
                System.out.println(i);
                sum=sum+i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口的实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象

        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中创建Thread对象，并调用start()

        new Thread(futureTask).start();

        try {
            //6.可以获取Callable中call()的返回值
            //get()返回值为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

创建线程的方式四：使用线程池

• 好处：
• 1.提高响应速度（减少了创建新线程的时间）
• 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
• 3.便于线程管理

•      corePoolSize:核心池的大小
  

•      maximumPoolSize：最大线程数
  

•      KeepAliveTime:线程没有任务时最多保持多长时间后会终止
  

class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1=(ThreadPoolExecutor)service;
        //设置线程池的属性
//        System.out.println(service.getClass());    获取接口的实现类
         service1.setCorePoolSize(10);
//         service1.setKeepAliveTime();


        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
//        service.submit(Callable callable);//适合适用于Callable
        service.shutdown();//关闭连接池
    }
}

线程的生命周期

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使Thread类。
及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。
运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能。
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态。
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。

线程的同步

在JAVA中，我们通过同步机制，来解决线程的安全问题。

• 同步的方式，解决了线程的安全问题
• 操作同步代码时只能有一个线程参与，其他线程等待，相当于是一个单线程的过程
• synchronized(同步监视器){
  需要被同步的代码
  }
  说明：

• 1.操作共享数据的代码即为需要被同步的代码
  

• 2.共享数据：多个线程共同操作的变量，比如：ticket就是共享数据
  

• 3.同步监视器：俗称：锁。任何一个类的对象，都可以充当锁。
  

• 要求：多个线程必须要共用同一把锁。
  

例子：创建三个窗口卖票，总票数为100张,使用实现Runnable接口的方法

class Window1 implements Runnable{
    private  int ticket=100;
//    Object obj=new Object();
//    任何一个类的对象，都可以充当锁。
    @Override
    public void run() {
        while(true){
                synchronized(this){//此时的this：唯一的Windows的对象            //方式二：synchronized(obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
    }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();
        //三个线程用的同一个Window1对象
        Thread t1= new Thread(w);
        Thread t2= new Thread(w);
        Thread t3= new Thread(w);
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

线程的死锁问题

死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
阻塞状态，无法继续。

解决方法：

• 专门的算法、原则
• 尽量减少同步资源的定义
• 尽量避免嵌套同步

线程通信

涉及到的三个方法：

• wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
• notify()：一旦执行此方法，就会唤醒被wait()的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
• notifyAll()：一旦执行此方法，就会唤醒所有被wait() 的线程
  说明:
• 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
• 2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。 否则，会出现异常。
• 3.wait(),notify(),notifyAll()三个方法定义在java.lang.object类中。

sleep()和wait()的区别：

• 1.相同点：一旦执行方法，都可以使得当前线程进入阻塞状态
  不同：
• 两个方法声明的位置不同：Thread类声明sleep()，Object类中声明wait()
• 调用的范围（要求）不同：sleep()可以在任何需要的场景下调用wait()必须使用在同步代码块或同步方法中。
  关于是否释放同步监视器?:
• 如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁(同步监视器)，而wait()会释放同步监视器。

wait() 与 notify() 和 notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待。

线程通信的例子：使用两个线程打印1-100.交替打印。

class Number implements Runnable{
    private  int number=1;
    @Override
    public void run() {
        while (true)
        {
            synchronized (this) {
                this.notify();
                if(number<100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;

                    try {
                        //使得调用如下方法的线程进入阻塞状态，自动释放锁
                       this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}