java多线程笔记

程序进程线程的基本概念

程序：为了完成任务，用某种语言编写的一组指令的集合，这个基本不会问

进程：程序的一次执行过程，或者正在运行的一个程序，有它自身的产生、存在和消亡的过程。

进程可进一步细化为线程，是一个程序内部的一条执行路径，一个进程可以由多个线程。一个进程内的多个线程共享相同的内存单元和地址空间，因此他们可以访问相同的变量和对象（所以多线程会带来数据的安全隐患）

下面一个java虚拟机的内部构造，在内存区域，方法区和堆是所有线程共有的，程序计数器，虚拟机栈和本地方法栈是每个线程独有的

单核cpu实际上是假的多线程，本质上是每个线程都要争抢时间片，抢到的执行，但是因为时间片非常短，所以，感觉不出来

并行：多个cpu同时执行多个任务
并发：一个CPU同时执行多个任务

多线程的优点
1.提高应用程序的响应，增强用户体验
2.提高CPU利用率
3.改善程序结构，将复杂进程分为多个线程

什么时候需要多线程
1.程序同时要执行两个或多个任务
2.程序需要实现一些要等待的任务
3.需要一些后台运行的程序

创建多线程

方式一：实现一个继承Thread类的子类

1.实现一个继承Thread类的子类
2.重写Thread类的run方法
3.创建Thread类的子类的对象
4.调用该对象的start方法

调用start方法实际上等于：1.启动新线程2.执行run方法。那么我们能不能直接调用run方法呢？不行，因为这样没有创建新线程，不就是变成单线程了吗

注：继承Thread类的子类的单个对象只能调用一次start方法，如果需要同时创建两个新线程的话，需要两个继承Thread类的子类的对象，然后分别调用两个子类的start方法

import org.junit.Test;

class MyThread extends Thread{

    @Override
    public void run() {
        //将需要此线程做的事声明在run方法中
        for (int i=0;i<11;i++){
            if (i%2==0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    @Test
    public void test() {
        MyThread myThread = new MyThread();
        myThread.start();
        //这里会报错
        myThread.start();

        System.out.println("hello");
    }
}

那么提个问题，如果我说我让线程start方法完全执行完了之后，再去调用同一个对象的start方法，可不可以呢？

myThread.start();
Thread.sleep(10000);
myThread.start();

答案是不行，依然会抛异常，因此一个线程对象，只能使用一次start，需要再新建线程，那就要再新建线程对象

实现多线程方式二：创建Thread匿名子类

如果该线程只用一次

new Thread(){
   @Override
   public void run(){
        for (int i=0;i<11;i++){
            if (i%2!=0) {
                System.out.println(i);
            }
        }
    }
}.start();

实现多线程方式3:实现runnable接口

class MThread implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<101;i++){
            if (i%2==0) {
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}

public class ThreadTest {

    @Test
    public void test() throws InterruptedException {
        MThread mThread = new MThread();
        new Thread(mThread).start();
    }
}

哪种创建方式更好？实现接口的更好

因为java继承是单继承，继承了Thread，有很大的局限性

Thread类常用方法

yield():让步，很重要
join() 让指定的线程限制性，指定的线程执行完之后，当前线程才会继续执行，谁join，谁调用，谁被join，在谁的方法体里面写，比如下面，在主线程的main函数里写myThread.join(),那么mythread这个线程执行完之后，主线程才会继续执行
stop不推荐使用

import org.junit.Test;

class MyThread extends Thread{


    @Override
    public void run() {
        //将需要此线程做的事声明在run方法中
        for (int i=0;i<101;i++){
            if (i%2==0) {
                System.out.println(Thread.currentThread().getName()+i);
            }
            if (i%20==0){
                yield();
            }
        }

    }

}

public class ThreadTest {

    @Test
    public void test() throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.setName("myThread");
        myThread.start();

        System.out.println("hello");

        for (int i=0;i<101;i++){
            if (i%2!=0) {
                System.out.println(Thread.currentThread().getName()+i);
            }
            if (i==20){
                myThread.join();
            }
        }
    }
}

线程是如何调度的

线程优先级：
注意：1.线程创建时继承父线程的优先级
2.低优先级只是调度概率低

线程的生命周期

五个状态，新建，就绪，运行，阻塞，死亡

线程的状态转化图如下

线程的同步

懒汉式创建可能会有线程安全问题

/*
    实现一个窗口类，在里面run方法，就是在卖票，一共50张票
 */

import org.junit.Test;

class Window implements Runnable{

    private int ticket = 50;

    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName()+"卖票"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class ThreadTest1 {

    @Test
    public void test(){
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}

上面是一个卖票的代码块，这个代码很明显的可以看出，有线程安全问题，会出现出重票和错票的问题，那么怎么修改？当一个线程在修改数据的时候，其他线程必须等待，直到该线程操作结束

同步方法一：同步代码块

如果你发现多个线程加上synchronized之后还是出现安全问题，那么可能就是锁不是同一把

只能有一个参与，所以synchronized是悲观锁

import org.junit.Test;

class Window implements Runnable{

    private int ticket = 50;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}


public class ThreadTest1 {

    @Test
    public void test(){
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}

因为在使用继承Thread类创建多线程的方式中，你需要创建多个不同的继承Thread类的对象，这时候的this指代的并不是同一对象，所以把this加到锁中会出问题，可以考虑使用 当前类.class这个对象

同步方法二：同步方法

将操作共享数据的代码，抽取成一个方法，并且在方法上加synchronized，在下面代码可以看到，在show方法上加synchronized关键字

import org.junit.Test;

class Window1 implements Runnable{

    private static int ticket = 50;
    Object obj = new Object();
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            show();
        }
    }

    public synchronized void show(){
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖票" + ticket);
            ticket--;
        } else {
            flag = false;
        }
    }

}


public class ThreadTest2 {

    @Test
    public void test(){
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}

如果是继承Thread类创建线程的方式，那么加synchronized关键字的方法必须是静态方法。

如果在方法上加synchronized关键字的话，会有默认的锁，非静态的同步方法，同步监视器为this（实际上就是你创建的对象） 静态同步方法，同步监视器为：当前类本身 Xxx.class

使用同步机制将单例中懒汉式改写为线程安全的

/**
* @Author: 刘志天
* @Date: 2021/2/26
 * 使用同步机制将单例中懒汉式改写为线程安全的
*/
class Bank{
    private Bank(){

    }

    private static Bank instance = null;
//方式一，效率低
/*    public static synchronized Bank getInstance(){
        if (instance == null){
            instance = new Bank();
        }
        return instance;
    }*/
   //方式二，效率高 
    public static Bank getInstance(){

        synchronized (Bank.class) {
            if (instance == null){
                instance = new Bank();
            }
        }
        return instance;
    }
}
public class BankTest {
}

死锁

public class ThreadTest3 {

    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append("a");
                    s2.append("1");
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append("c");
                    s2.append("3");
                    synchronized (s2){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
    
}

问：上述代码执行可能会有哪几种情况？
1.输出
12
ab
1234
abcd
这是第一个线程先执行，执行完再执行第二个线程
2.输出
34
cd
3412
cdab
这是第二个线程先执行，执行完再执行第一个
3.死锁
在每个线程第一个锁的内部加一个sleep，效果会更明显些
线程1手握锁s1,要获取s2，线程2手握锁s2，要获取s1。这样就会造成死锁

解决线程安全方法3：lock锁

还是卖票，使用lock解决线程安全问题

import org.junit.Test;
import java.util.concurrent.locks.ReentrantLock;

class Window2 implements Runnable{

    private int ticket = 100;
    //实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //调用lock方法
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "卖票" + ticket);
                    ticket--;
                } else {
                    break;
                }
            } finally {
                //调用解锁方法，解锁lock
                lock.unlock();
            }
        }
    }

}

public class ThreadTest4 {

    @Test
    public void test(){
        Window2 w = new Window2();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.start();
        t2.start();
        t3.start();
    }
}

面试题：lock和synchronized的异同？
同：都可以解决线程安全问题
异：synchronized机制在执行完同步代码以后，自动释放同步监视器
lock需要手动的去启动同步和手动的结束同步
建议优先使用lock

线程通信

调用这三个方法的必须是同步监视器

sleep()和wait()异同？
同：都会对线程进行阻塞
异：1.声明的位置不同，sleep在Thread类中声明，wait在Object类中声明
2.sleep可以在任何场景下调用，wait()只能在同步代码块和同步方法里
3.sleep执行完之后会释放同步监视器，线程自动被唤醒，wait()不会释放同步监视器，线程不自动唤醒。

jdk5.0新增的线程创建方式

方式1，实现Callable接口

如何理解Callable比Runnable强大？
1.call方法可以有返回值，
2.call方法可以抛异常，被外面程序捕获
3.callable支持泛型，call方法返回值类型可以自定义
下面是使用Callable的实例

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//创建一个实现callable接口的实现类
class NumberThread implements Callable<Integer>{
    //实现call方法
    @Override
    public Integer call() throws Exception {
        int count = 0;
        for(int i = 1;i < 100;i++){
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+i);
                count += i;
            }
        }
        return count;
    }
}

public class ThreadNew {

    public static void main(String[] args) {
        //3.创建callable接口实现类对象
        NumberThread numberThread = new NumberThread();
        //4.将此callable接口实现类对象传入到FutureTask构造器中，创建FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(numberThread);
        //5.以FutureTask对象作为参数，传递到Thread构造器中，开启Thread线程
        new Thread(futureTask).start();

        Integer integer = null;
        try {
            //get为获取call方法的返回值
            integer = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(integer);
    }
}

方式二：使用线程池

使用线程池代码

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class ThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);

        //设置线程池属性
        //executorService.setKeepAliveTime();
        //executorService.setCorePoolSize();

        //适合使用runnable
        Runnable window = new Window2();
        executorService.execute(window);
        //适合使用Callable
        Callable numberThread = new NumberThread();
        executorService.submit(numberThread);

        //关闭连接池
        executorService.shutdown();

    }
}