Java多线程

新建线程的方法

继承Thread类

声明并实现一个继承于Thead类的类，然后重写类的run方法，最后在主线程中实例化并调用start方法使得线程就绪。

实现Runnable接口

编写一个实现Runnable接口的类，重写run方法，对其实例化。
将实例化后的对象传入Thread构造器并实例化一个对象。
调用该对象的start方法使线程就绪。

实现Callable接口

1、创建Callable接口的实现类，并实现call()方法，且该call方法有返回值；
2、使用FutureTask类来包装Callable对象；
3、使用FutureTask对象作为Thread对象的target创建并启动新线程；
4、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。

优点

call()方法可以有返回值；
call()方法能抛出异常；
Callable支持泛型。

解决线程安全问题的方法

synchronized

使用synchronized修饰符去修饰

• 同步代码块
• 同步方法

Lock

实例化一个ReentrantLock类的实例，并手动上锁和解锁
只有Lock方法块

线程通信

线程之间的交流。实际上就是两个方法的使用。

• wait()
  使得当前的线程进入阻塞状态，并释放锁。
• notify()/notifyAll()
  唤醒一个（所有）的线程。

使用前提：
这三个方法必须使用在同步代码块或同步方法中。
这三个方法的调用者必须是synchronized的同步监视器。否则会出现异常。
实际上这三个方法是定义在Object类中的。

经典例题——生产者/消费者问题

package com.huangshu.java;

import java.util.Currency;

/**
 * 生产者消费者问题
 */
class Producer implements Runnable{
    private Clerk clerk;
    public Producer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"生产：");
        while(true) {
            clerk.produceProducter();
        }
    }
}
class Customer implements Runnable{
    private Clerk clerk;
    public Customer(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"消费：");
        while(true) {
            clerk.consumeProducter();
        }
    }
}
class Clerk{

    private int productCount = 0;
    public synchronized void produceProducter() {
        if (productCount < 20) {
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个" );
            notify();
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumeProducter() {
        if (productCount > 0) {
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个" );
            productCount--;
            notify();
            try {
                Thread.sleep(90);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer producer = new Producer(clerk);
        Customer customer = new Customer(clerk);

        Thread thread1 = new Thread(producer,"Producer");
        Thread thread2 = new Thread(customer,"Customer");

        thread1.start();
        thread2.start();
    }
}

线程池

背景：如果经常销毁、使用量特别大的资源。
思路：提前创建很多个线程放入线程池中，使用时直接获取，使用完毕就放回池中。可以避免频繁创建销毁、实现重复利用。
好处：

• 提高响应速度（减少了创建新线程的时间）；
• 降低资源消耗（重复利用，不需要每次都创建以下）；
• 便于线程管理。

		ExecutorService service = Executors.newFixedThreadPool(10);
		ThreadPoolExcutor service1 = (ThreadPoolExcutor) service;
        service.execute(new NumberThread());  //适合用于Runnable
//      service.submit();   //适合用于Callable
        service.shutdown();     //关闭线程池