线程的生命周期

线程的同步机制

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

方式一:同步代码块

synchronized(同步监视器){
		//需要被同步的代码
}

说明:
1.操作共享数据的代码，即为需要被同步的代码。-->不能包含代码多了，也不能包含代码少了。
2.共享数据:多个线程共同操作的变量。
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
要求:多个线程必须要共用同一把锁。
补充:在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

方式二:同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。
关于同步方法的总结:
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身

方式三：Lock锁 ---JDK5.0新增

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了Lock ，它拥有与svnchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
1.实例化ReentrantLock
2.调用锁定方法：lock()
3.调用解锁方法：unlock()

线程的死锁问题

1.死锁的理解:不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2.说明:
1）出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
2）我们使用同步时，要避免出现死锁。
解决方法
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步

线程通信

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

不会释放锁的操作

JDK5.0新增多线程创建的方式

新增方式一:实现Callable接口。--- JDK 5.0新增

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现caLL方法，将此线程需要执行的操作声明在caLL()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                system.out.print1n(i);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();
    }
  }
}

说明:
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

1. call()可以返回值的。
   
2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
   
3. Callable是支持泛型

新增方式二:使用线程池

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());
        //servicei.setCorePoolSize(15);
        //servicei.setKeepAliveTime( );
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合使用于Runnable
        service.execute(new NumberThread1());//适合使用于Runnable
        //service.submit(Callable callable)//适合使用于Callable
        service.shutdown();
    }
}

说明:
好处:
1.提高响应速度（减少了创建新线程的时间)
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
corePooLsize:核心池的大小
maximumPooLsize:最大线程数
keepAliveTime:线程没任务时最多保持多长时间后会终止