多线程学习笔记

多线程相关概念

• 线程就是独立的执行路径
• 程序运行时，即使没有自己创建线程，后天也会有多个线程，如主线程（main）、GC（垃圾回收）进程
• main() 称之为主线程，为系统的主入口，线程的运行由调度器安排调度，调度器是与操作系统密切相关的，先后顺序不能人为干预
• 对同一份资源进行操作时，会存在资源争抢的问题，需要加入并发控制
• 线程会带来额外的开销，如cpu调度时间，并发控制开销
• 每个线程在自己的工作内存互相交互，内存控制不当会造成数据不一致
• synchronized修饰方法的时候，锁的对象是this；修饰同步块的时候，锁的对象是同步块括号中的对象。锁的对象，是需要增删改的对
• ReentrantLock，Lock的一个典型实现类，可重入锁，显示的锁，需要手动的开关，不能锁方法。
• 自旋锁，相较于普通的互斥锁，会在获取不到锁的时候不会进入阻塞状态，而是开始循环，再一段时间内（一般设置循环次数）多次尝试获取锁。
• CAS，Compare And Swap，是一种无锁编程的思想，也是一种乐观锁的实现。通过在交换时，比较线程内的oldvalue是否和当前加锁对象的value一致来判断本次交换能否提交。一般由具体的工具类实现，例如AtomicInteger类。要特别注意，Compare和Swap这两个操作要同步，否则还是会有线程安全问题。

多线程的创建方式

一、继承 Thread 类

1.实现方式

• 第一步：继承 Thread 类
• 第二步：重写 run()方法
• 第三步：创建 Thread 子类对象
• 第四步：调用 start() 方法启动线程

//创建线程方式1：继承Thread类，重写run()，调用start()开启线程
public class Thread1 extends Thread {

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 15; i++) {
            System.out.println("run方法体" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //main线程，也叫主线程

        //创建线程对象
        Thread1 thread1 = new Thread1();
        //调用start()开启线程
        thread1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main线程" + i);
            //休眠一下，便于观察
            Thread.sleep(50);
        }

        /** cpu调用是乱序交替执行的，每次输出结果都不一样，线程不一定立即执行，cpu安排调度 */
    }
}

2.start() 和 run() 方法区别

• 用 start() 方法来启动线程，是真正实现了多线程， 通过调用 Thread 类的 start() 方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行 run() 方法。但要注意的是，此时无需等待 run() 方法执行完毕，即可继续执行下面的代码。所以 run() 方法并没有实现多线程。
• 调用 run() 方法仅仅只是调用了一个子类中重写的父类方法，并没有真正开启一个线程，还是当前线程运行，也就是 main 线程。

3.评价

线程不一定立即执行，cpu安排调度。因为 Java 是单继承的，一个类继承了 Thread 类就不能继承其它类，所以通常不采用这个办法创建多线程。

二、实现 Runnable 接口

1.实现方式

• 第一步：实现 Runnable
• 第二步：重写 run()方法
• 第三步：创建实现类的对象
• 第四步：将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象
• 第五步：通过 Thread 类的对象调用 start() 方法启动线程

//创建线程方式2：实现Runnable接口，重写run()，执行线程需要丢给Runnable接口实现类(Thread类实现了Runnable)，调用start开启线程
public class Thread2 implements Runnable {

    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 15; i++) {
        	Thread.sleep(1000);
            System.out.println("run方法体" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //main线程，也叫主线程

        //创建线程对象，通过线程对象来启动线程，代理
        Thread2 thread2 = new Thread2();
        Thread thread = new Thread(thread2);

        //调用start()开启线程
        thread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main线程" + i);
            //休眠一下，便于观察
            Thread.sleep(1000);
        }

        /** cpu调用是乱序交替执行的*/
    }
}

2.Runnable 接口与继承 Thread 类的方式作比较

• 开发中：优先选择：实现Runnable接口的方式
• 原因：1.实现的方式没类的单继承性的局限
• 2. 实现的方式更适合来处理多个线程共享数据的情况。
• 联系：public class Thread implements Runnable
• 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。目前两种方式，要想启动线程，都是调用的Thread类中的start()。

三、实现 Callable 接口 —JDK 5.0新增

1.实现方式

runable中重写run()不如callable中的call()强大；因为call()具有返回值；并且该方法可以抛异常；需要借助FutureTask类；

• 1.创建一个callable的实现类；
• 2.实现callable中的call()；
• 3.创建一个实现类对象；
• 4.将创建的对象作为参数传递到FutureTask的构造器中，并创建FutureTask对象；
• 5.将FutureTask对象作为参数传递到Thread类中，并创建Thread对象，然后调用start方法；

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 创建线程的方式三：实现callable接口。---JDK 5.0新增
 *是否多线程？否，就一个线程
 *
 * 比runable多一个FutureTask类，用来接收call方法的返回值。
 * 适用于需要从线程中接收返回值的形式
 * 
 * //callable实现新建线程的步骤：
 * 1.创建一个实现callable的实现类
 * 2.实现call方法，将此线程需要执行的操作声明在call（）中
 * 3.创建callable实现类的对象
 * 4.将callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象
 * 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法启动（通过FutureTask的对象调用方法get获取线程中的call的返回值）
 * 
 * */


//实现callable接口的call方法
class NumThread implements Callable{

    private int sum=0;//

    //可以抛出异常
    @Override
    public Object call() throws Exception {
        for(int i = 0;i<=100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {

    public static void main(String[] args){
        //new一个实现callable接口的对象
        NumThread numThread = new NumThread();

        //通过futureTask对象的get方法来接收futureTask的值
        FutureTask futureTask = new FutureTask(numThread);

        Thread t1 = new Thread(futureTask);
        t1.setName("线程1");
        t1.start();

        try {
            //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
           Object sum = futureTask.get();
           System.out.println(Thread.currentThread().getName()+":"+sum);
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2. Callable 和 Runnable 对比

Runnable接口	Callable接口
重写run()方法	重写call()方法
run()没有返回值	call()有返回值
run()没有声明抛出异常	call()声明抛出Exception
没有汇总各个线程结果的机制	有汇总各个线程结果的机制

四、使用线程池

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(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

说明：

好处：

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

参数设置：

 corePoolSize：核心池的大小
 maximumPoolSize：最大线程数
 keepAliveTime：线程没任务时最多保持多长时间后会终止

总结：

方法⼀：

• 优点：简单，好⽤。
• 缺点：只能继承⼀个类，不能再继承其他⽗类了。

方法⼆、三：

• 优点：只实现了接⼝，还可以继承其他⽗类。共享对象（target），适合多线程共享同⼀个资源的情况。
• 缺点：编程稍稍复杂⼀点，如果访问当前线程，则使⽤Thread.currentThread()⽅法。