JavaSE基础：多线程

JavaSE基础：多线程

前言

线程的基础知识点

一、基本概念

1、什么是进程？什么是线程？

	进程是一个应用程序（1个进程是一个软件）。
	线程是一个进程中的执行场景/执行单元。
	一个进程可以启动多个线程。

2、java程序中的线程

	java HelloWorld 回车之后。
	会先启动JVM，而JVM就是一个进程。
	JVM再启动一个主线程调用main方法。
	同时再启动一个垃圾回收线程负责看护，回收垃圾。
	最起码，现在的java程序中至少有两个线程并发，
	一个是垃圾回收线程，一个是执行main方法的主线程。

3、进程和线程的关系

	阿里巴巴：进程
		马云：阿里巴巴的一个线程
		童文红:阿里巴巴的一个线程

	进程可以看做是现实生活当中的公司。
	线程可以看做是公司当中的某个员工。

	注意：
		进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享的！）
			魔兽游戏是一个进程
			酷狗音乐是一个进程
			这两个进程是独立的，不共享资源。

		线程A和线程B呢？
			在java语言中：
				线程A和线程B，堆内存和方法区内存共享。
				但是栈内存独立，一个线程一个栈。
		
			假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，
			互不干扰，各自执行各自的，这就是多线程并发。
		
		火车站，可以看做是一个进程。
		火车站中的每一个售票窗口可以看做是一个线程。
		我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你。
		所以多线程并发可以提高效率。

		java中之所以有多线程机制，目的就是为了提高程序的处理效率。
		
		使用了多线程机制之后，main方法结束，程序可能还没有结束。
		main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在
		压栈弹栈。

4、对于单核的CPU来说，真的可以做到真正的多线程并发吗？

	对于多核的CPU电脑来说，真正的多线程并发是没问题的。
		4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

	什么是真正的多线程并发？
		t1线程执行t1的。
		t2线程执行t2的。
		t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

	单核的CPU表示只有一个大脑：
		不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。
		对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于
		CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情
		同时在做！！！！！
			线程A：播放音乐
			线程B：运行魔兽游戏
			线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，
			游戏一直在运行，给我们的感觉是同时并发的。
	
	电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，
	人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像
	一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在
	这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

5、实现线程的两种方式

java支持多线程机制。并且java已经将多线程实现了，我们只需要继承就行了。

第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。
	// 定义线程类
	public class MyThread extends Thread{
		public void run(){
		
		}
	}
	// 创建线程对象
	MyThread t = new MyThread();
	// 启动线程。
	t.start();

第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
	// 定义一个可运行的类
	public class MyRunnable implements Runnable {
		public void run(){
		
		}
	}
	// 创建线程对象
	Thread t = new Thread(new MyRunnable());
	// 启动线程
	t.start();

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承
其它的类，更灵活。

6、线程对象的生命周期

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

二、线程的调度和数据安全

1、常用的线程调度模型

	抢占式调度模型：
		那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
		java采用的就是抢占式调度模型。

	均分式调度模型：
		平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
		平均分配，一切平等。
		有一些编程语言，线程调度模型采用的是这种方式。

2、有关线程调度的方法

	实例方法：
		void setPriority(int newPriority) 设置线程的优先级
		int getPriority() 获取线程优先级
		最低优先级1
		默认优先级是5
		最高优先级10
		优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）
	
	静态方法：
		static void yield()  让位方法
		暂停当前正在执行的线程对象，并执行其他线程
		yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
		yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
		注意：在回到就绪之后，有可能还会再次抢到。
	
	实例方法：
		void join()  
		合并线程
		class MyThread1 extends Thread {
			public void doSome(){
				MyThread2 t = new MyThread2();
				t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
			}
		}

		class MyThread2 extends Thread{
			
		}

3、数据安全（重点）

	以后在开发中，我们的项目都是运行在服务器当中，
	而服务器已经将线程的定义，线程对象的创建，线程
	的启动等，都已经实现完了。这些代码我们都不需要
	编写。

	最重要的是：编写的程序需要放到一个多线程的环境
	下运行，你更需要关注的是这些数据在多线程并发的
	环境下是否是安全的。

4、存在安全问题的三个条件

		条件1：多线程并发。
		条件2：有共享数据。
		条件3：共享数据有修改的行为。
		
		满足以上3个条件之后，就会存在线程安全问题。

5、解决线程安全问题

	线程排队执行。（不能并发）。
	用排队执行解决线程安全问题。
	这种机制被称为：线程同步机制。
	实际上是线程不能并发了，线程必须排队执行。		
	线程排队了就会牺牲一部分效率，数据安全第一位，
	只有数据安全了，我们才可以谈效率。数据不安全，就没有效率的事儿。
	
	开发中应该怎么解决线程安全问题？
	
	是一上来就选择线程同步吗？
	不是，synchronized会让程序的执行效率降低，用户体验不好。
	系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择
	线程同步机制。

	第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

	第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样
	实例变量的内存就不共享了。（一个线程对应1个对象，
	100个线程对应100个对象，对象不共享，就没有数据安全问题了。）

	第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候
	就只能选择synchronized了。线程同步机制。

6、异步和同步编程模型

	异步编程模型：
		线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，
		谁也不需要等谁，这种编程模型叫做：异步编程模型。
		其实就是：多线程并发（效率较高。）

		异步就是并发。

	同步编程模型：
		线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行
		结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，
		两个线程之间发生了等待关系，这就是同步编程模型。
		效率较低。线程排队执行。

		同步就是排队。

7、三大变量的线程安全问题

实例变量：在堆中。

静态变量：在方法区。

局部变量：在栈中。

以上三大变量中：
	局部变量永远都不会存在线程安全问题。
	因为局部变量不共享。（一个线程一个栈。）
	局部变量在栈中。所以局部变量永远都不会共享。

实例变量在堆中，堆只有1个。
静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量和常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

8、局部变量的使用

建议使用：StringBuilder。
因为局部变量不存在线程安全问题。选择StringBuilder。
StringBuffer效率比较低。

ArrayList是非线程安全的。
Vector是线程安全的。
HashMap HashSet是非线程安全的。
Hashtable是线程安全的。

9、synchronized三种写法

	第一种：同步代码块
		灵活
		synchronized(线程共享对象){
			同步代码块;
		}

	第二种：在实例方法上使用synchronized
		表示共享对象一定是this
		并且同步代码块是整个方法体。
	
	第三种：在静态方法上使用synchronized
		表示找类锁。
		类锁永远只有1把。
		就算创建了100个对象，那类锁也只有一把。
	
	对象锁：1个对象1把锁，100个对象100把锁。
	类锁：100个对象，也可能只是1把类锁。

三、守护线程

1、概念

	java语言中线程分为两大类：
		一类是：用户线程
		一类是：守护线程（后台线程）
		其中具有代表性的就是：垃圾回收线程（守护线程）。

	守护线程的特点：
		一般守护线程是一个死循环，所有的用户线程只要结束，
		守护线程自动结束。
	
	注意：主线程main方法是一个用户线程。

	守护线程用在什么地方呢？
		每天00:00的时候系统数据自动备份。
		这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
		一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
		如果结束了，守护线程自动退出，没有必要进行数据备份了。

2、例子

public class DaemonTest {
    public static void main(String[] args){
        Thread thread = new MyThread00();
        thread.setName("备份线程");
        thread.setDaemon(true);
        thread.start();
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"用户线程--->"+i);
        }
    }
}
class MyThread00 extends Thread{
    public void run(){
        int i=0;
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--->备份完成"+(++i));
        }
    }
}

四、定时器

1、概念

定时器的作用：
	间隔特定的时间，执行特定的程序。

	每周要进行银行账户的总账操作。
	每天要进行数据的备份操作。

	在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
	那么在java中其实可以采用多种方式实现：
		
		可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
		任务。这种方式是最原始的定时器。（比较low）

		在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
		不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
		定时任务的。

		在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
		这个框架只要进行简单的配置，就可以完成定时器的任务。

2、例子

/*
    关于java.util.Timer
    计时器
    可以使用sleep，但是过于麻烦，所以引入计时器
    Timer() 创建一个新的计时器。
    Timer(boolean isDaemon) 创建一个新的定时器，其相关线程可以指定为 run as a daemon 。
    Timer(String name) 创建一个新的定时器，其相关线程具有指定的名称。
    Timer(String name, boolean isDaemon) 创建一个新的定时器，其相关线程具有指定的名称，可以指定为 run as a daemon 。

    Timer中的实例方法
    void schedule(TimerTask task, Date time) 在指定的时间安排指定的任务执行。
    void schedule(TimerTask task, Date firstTime, long period) 从指定的时间开始,对指定的任务执行重复的固定延迟执行 。

    public abstract class TimerTask
    extends Object
    implements Runnable
    是一个抽象类，需要进行继承并且重写方法。
 */

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) throws ParseException {
        // 创建计时器对象
        Timer timer = new Timer();
        // 将时间进行格式化
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 赋予firsttime引用时间
        Date firsttime = simpleDateFormat.parse("2020-12-2 0:46:59");
        // 调用timer中的schedule方法进行任务执行
        // timer.schedule(定时任务,第一次执行的时间，每隔多久进行一次);
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" finish!");
            }
        },firsttime);
    }
}
//class TimerTaskTest01 extends TimerTask {
//
//    @Override
//    public void run() {
//        System.out.println(Thread.currentThread().getName()+"完成！");
//    }
//}

四、实现线程的第三种方式

/*
    实现线程的第三种方式
    FutureTask(Callable<V> callable)
    创建一个 FutureTask ，它将在运行时执行给定的 Callable 。
    FutureTask(Runnable runnable, V result)
    创建一个 FutureTask ，将在运行时执行给定的 Runnable ，并安排 get将在成功完成后返回给定的结果。

    如果传入Callabale<V>则就是有返回值的线程，如果使用Runnable则没有返回值
    实现Callable接口
	这种方式实现的线程可以获取线程的返回值。
	之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
	
	思考：
		系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
		会有一个执行结果，我们怎么能拿到这个执行结果呢？
		使用第三种方式：实现Callable接口方式。
 */
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {
    public static void main(String[] args) {
        // 创建一个“未来任务类”
        FutureTask futureTask = new FutureTask(new Callable() {
            // 创建一个实现Callable接口的线程
            // 重写的call()方法相当于run()方法
            @Override
            public Object call() throws Exception {
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method over!");
                int a = 1;
                int b = 2;
                return a + b;
            }
        });
        // 创建线程对象
        Thread thread = new Thread(futureTask);
        // 线程启动
        thread.start();
        // 获取线程的返回值
        try {
            Object object = futureTask.get();
            // 这边的get()方法会在这里等待thread线程执行完成才能获取到返回值，进入阻塞状态
            System.out.println("线程执行结果："+ object);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

五、Object类中的wait和notify方法（生产者消费者模式）

1、概念

第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类中自带的。
	wait方法和notify方法不是通过线程对象调用，
	不是这样的：t.wait()，也不是这样的：t.notify()..不对。
	
第二：wait()方法作用？
	Object o = new Object();
	o.wait();

	表示：
		让正在o对象上活动的线程进入等待状态，无期限等待，
		直到被唤醒为止。
		o.wait();方法的调用，会让“当前线程（正在o对象上
		活动的线程）”进入等待状态。

第三：notify()方法作用？
	Object o = new Object();
	o.notify();

	表示：
		唤醒正在o对象上等待的线程。
		
	还有一个notifyAll()方法：
		这个方法是唤醒o对象上处于等待的所有线程。

2、例子

/*
    生产者消费者模式
    创建一个容器，一个生产者线程，一个消费者线程
    合理运用 .wait()方法和.notify()方法
 */
 
import java.util.ArrayList;
import java.util.List;

public class Producer_Cusumer_Pattern {
    public static void main(String[] args) {
        // 创建仓库
        List list = new ArrayList();
        // 创建生产者线程
        Thread t1 = new Thread(new Producer(list));
        // 创建消费者线程
        Thread t2 = new Thread(new Cusumer(list));
        t1.setName("生产者线程");
        t2.setName("消费者线程");
        // 启用线程
        t1.start();
        t2.start();
    }
}
// 生产者线程
class Producer implements Runnable {
    // 共享的仓库
    private List list;
    public Producer(List list){
        this.list = list;
    }
    @Override
    public void run() {
        while(true) {
            synchronized(list) {
                if(list.size()>0) {
                    // 使当前线程等待
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Object object = new Object();
                list.add(object);
                System.out.println(Thread.currentThread().getName()+"--->"+object);
                list.notify();
            }
        }
    }
}
// 消费者线程
class Cusumer implements Runnable {
    // 共享的仓库
    private List list;
    public Cusumer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (list) {
                if (list.size()==0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Object object = list.remove(list.size()-1);
                System.out.println(Thread.currentThread().getName()+"--->"+object);
                list.notify();
            }
        }
    }
}

以上知识点由观看b站动力节点java教学视频总结得出的