java多线程学习笔记

线程简介

线程是指在进程基础上的进一步划分，想成是比进程更小的单位。线程启动的所占用的资源更少，进程比线程慢。java是一个多线程的语言，其指向的性能更快。

多线程编程

如果要实现多线程的主类，有两类途径：
1.继承一个Thread类；
2.【推荐】实现Runable、Callable接口。

继承Thread类实现多线程

java.lang.Thread是线程操作的一个核心类。
启动多线程：调用start()方法；
线程对象变成了交替执行；

为什么通过start()方法来调用run()方法，而不是直接调用run方法来直接执行

每一个线程对象只能启动一次不能启动多次。
在start() 方法中调用了一次start0()方法，这个方法是native方法（调用本机的原生系统函数）

使用Runnable接口实现多线程

Thread类的核心功能是进行线程的启动，但是一个类直接继承了Thread类就造成了单继承的局限，所以通过Runnable接口打破这个局限。
在Runnable中同时存在一个run()方法。
启动多线程通过Thread的一个构造方法来启动多线程。
多线程的启动永远都是Thread中的start()方法。

Thread 和 Runnable的区别

Thread的主要功能是资源调度。
在多线程的原理上使用的就是代理设计模式。
使用Runnable可以实现数据共享的概念（并不是说Thread不能）。

通过Callable实现多线程

java.util.concurrent，这个开发包主要是高性能编程使用的（提供高并发操作）
Runnable中的run()方法没有返回值，但很多时候需要返回值，这是就需要使用Callable实现多线程（有返回值）。

多线程常用操作方法

线程的命名和取得

多线程的运行状态时不确定的，多线程的操作必须有一个可以明确表示出线程对象的信息（线程名称）。

1.public Thread(Runnable target, String name)
2.public final void setName(String name)
3.public final String getName()

取得当前线程对象：public static Thread currentThread();
如果没有设置线程名字，java则会自动定义一个线程的名字（线程名字如果要自定，要避免重复，并且中间不要修改）

线程休眠

线程休眠指的是让线程暂缓执行，等到了预计的时间后在回复执行。
方法：public static void sleep(long millis);

线程的优先级

线程的优先级指的是优先级越高越有可能执行。在Thread中提供了以下优先级操作的方法：

设置优先级：public final void setPriority(int new Priority)
取得优先级：public final int getPriority()

优先级的设置可以通过Thread中的常量来决定；
最高优先级：public static final int MAX_PRIORITY;
中等优先级：public static final int NORM_PRIORITY;
最低优先级：public static final int MIN_PRIORITY;
主方法的优先级是中等优先级。

线程的同步与死锁

线程同步

线程同步虽然可以保证数据的完整性（线程安全操作），但其执行的速度会很慢。
同步的本质：一个线程等待另一个线程执行完后才可以执行。

线程死锁

小心使用同步，过多的同步可能会造成死锁。

综合案例：生产者与消费者

生产者和消费者是一道经典的供求案例。
现在假设生产者负责生产数据，生产者生产数据后，消费者就要把这些数据取走。

sleep()和wait()的区别

sleep()是Thread中的方法，到了一定的时候可以自动唤醒。
wait()是Object中的方法，如果想要唤醒，必须使用notify()或者notifyAll()方法才可以唤醒。

线程池

线程池就是多个线程封装在一起进行操作。

创建无限大小的线程池

package multithread.learn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestDemo
{
    public static void main(String[] args) throws Exception
    {
        //现在创建了一个线程池的模型(无限大小)，但是现在里面没有线程
        ExecutorService executorService = Executors.newCachedThreadPool();

        for(int i=0;i<10;i++) {
            Thread.sleep(200);
            executorService.submit(new Runnable(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }

            });
        }

        executorService.shutdown();//关闭线程池
    }
}

创建单线程的线程池（无论何时线程池中只有一个线程工作）

package multithread.learn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestDemo
{
    public static void main(String[] args) throws Exception
    {
        //现在创建了一个线程池的模型(单线程)，但是现在里面没有线程
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        for(int i=0;i<10;i++) {
            Thread.sleep(200);
            executorService.submit(new Runnable(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }

            });
        }
        executorService.shutdown();//关闭线程池
    }
}

创建固定大小的线程池

package multithread.learn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestDemo
{
    public static void main(String[] args) throws Exception
    {
        //现在创建了一个线程池的模型(固定大小)，但是现在里面没有线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        for(int i=0;i<10;i++) {
            Thread.sleep(200);
            executorService.submit(new Runnable(){
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }

            });
        }
        executorService.shutdown();//关闭线程池
    }
}

定时调度池

package multithread.learn;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestDemo
{
    public static void main(String[] args) throws Exception
    {
        //现在创建了一个具备3个大小程度的线程池的模型(定时调度)，但是现在里面没有线程
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

        for(int i=0;i<10;i++) {
            executorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            }, 3, 2, TimeUnit.SECONDS);//使用的是一个以秒为单位，3秒后开始执行，而后每2秒执行一次
        }
    }
}