多线程学习笔记

在学习java的过程中学习到了多线程相关的知识，记录了一些笔记，留给自己以后复习用，也欢迎大家一起来找找有些什么错漏的地方，我会在之后的学习中也会改正。

多线程

进程

一般指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个进程可以有多个线程

线程

是进程中的一个执行路径，共享一个内存空间，进程之间可以自由切换，并发执行，一个进程最少有一个线程

线程实际上是进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

每个线程都有自己的栈空间，共用一份堆内存

由一个线程所调用的方法，这个方法也会执行在这个线程里面

线程调度

提高cpu的使用率

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java使用的为抢占式调度。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

同步与异步

线程安全——同步（排队执行）效率低，数据安全

线程不安全——异步（同时执行）效率高、数据不安全

并发与并行

并发：指两个或多个事件在同一个时间段内发生

程序在一天的同时发生的事情就是一天的并发量

并行：指两个过多个事件在同一时刻发生**（同时发生）**

错误的说法：有1000个用户在并行

多线程技术

Therad

有一个简单的实现方式、通过匿名内部类的方式重写run方法可以很方便的实现一个线程

继承Thread实现多线程的方法

run方法

继承Thread重写run方法，用于给线程执行的任务

重写线程要执行的任务方法

这个执行路径的触发方式，不是调用run方法，而是通过Thread对象的start()方法来启动任务

Runnable（接口）

实现Runnable与继承Thread相比有如下的优势

1.通过创建任务，给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况

2.避免单继承所带来的的局限性

3.任务与本身是分离的，提高程序的健壮性

4,。后续学习的线程池技术，接受Runnable类型的任务，不接受Thread类型的任务

实现Runnable流程：

首先创建一个类实现Runnable接口，重写里面的run方法

1.创建一个任务对象

MyRunnable r = new MyRunnable();

2.创建一个线程，并为其分配一个任务

Thread t = new Thread(r);//r为分配的任务

3.执行这个任务（调用start()方法）

t.start();

Thread类

不管是继承Thread还是实现Runnable，都需要使用到Thread类中的方法，现在就详细的介绍下Thread类中的常用方法

构造方法

Thread()         //创建一个线程，没有指定任务

Thread(Runnable target)  //创建一个线程，传入Runnable指定一个线程所要做的任务

Thread(Runnable target, String name)//创建一个线程，传入Runnable指定一个线程所要做的任务 给线程起一个名称，可以通过getname获取它的名称

Thread(String name)  //创建一个线程，单独传一个名称

方法

getname()   //返回线程的名称
    
getId()  	//返回此Thread的标识符
    
setPriority()	//设置线程的优先级
    //MAX_PRIORITY	最大优先级
    //MIN_PRIORITY	最低优先级
    //NORM_PRIORITY	默认优先级
getPriority()	//返回线程的优先级
start()		//线程执行的方法，java虚拟机调用此线程的run方法
sleep(long millis) //使当前正在执行的线程休眠指定的毫秒数（millis）
sleep(long millis,int nanos)  //使当前正在执行的线程休眠指定的毫秒数（millis）加纳秒数（nanos）
setDaemon(boolean on) //将此线程标记为daemon线程或用户线程
currentThread()  //获取当前正在执行的线程对象

线程的中断

一个线程是一个独立的执行路径，它是否应该接受，应该由其自身决定，因为里面有些资源在线程被结束时未被释放，造成资源的占用。产生内存垃圾

线程分为守护线程和用户线程

守护线程——通过setDaemon变为守护线程

守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡

用户线程——直接创造的线程

当一个进程不包含任何存活的用户线程时，进行结束，

线程不安全

原因：多个线程同时执行或操作了一个数据，导致数据的出错。

解决方法：

同步代码块和同步方法都属于隐式锁

同步代码块

锁对象要看同一个锁

synchronized（锁对象）{}

同步方法

将方法修饰符添加synchromized来使用，也是使用锁来保证线程安全

显示锁 Lock 子类 ReentrantLock

自己创建一个锁

Lock l = new ReentrantLock();
l.lock();
l.unlock();

显示锁和隐式锁的区别

公平锁和不公平锁

Lock l = new ReentrantLock(传入参数);

参数为true就是公平锁，不是就是不公平锁，以上的三个锁都为不公平锁

线程死锁

多线程通信问题

通过sleep方法来解决线程通信问题

线程的6种状态

new：线程刚被创建，还未启动

Runnable：正在执行的状态

Blocked：被阻塞等待监视器锁定的线程（排队状态）

Waiting：无限的等待的状态

TimedWaiting：指定时间等待的状态（时间到了自动唤醒）

Terminated：结束状态

Callable

Runnable 与 Callable

接口定义 
//Callable接口
public interface Callable<V> {    
V call() throws Exception; 
} //Runnable接口
public interface Runnable {    
public abstract void run(); 
}

Callable使用步骤

1.  编写类实现Callable接口 , 实现call方法        
class XXX implements Callable<T> {            		@Override            
    public <T> call() throws Exception {                 return T;            
    }        
} 
2.  创建FutureTask对象 , 并传入第一步编写的Callable类对象        
FutureTask<Integer> future = new FutureTask<>(callable); 
3.  通过Thread,启动线程        
new Thread(future).start();

Runnable 与 Callable的相同点

• 都是接口

• 都可以编写多线程程序

• 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

• Runnable没有返回值；

• Callable可以返回执行结果 Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。