单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
只有在多核 CPU 系统中，这些程序彩色真正意义上的的同时执行。
目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。通过任务管理器可以很方便地查看自己电脑CPU的核数，如下图所示。
并行：多个CPU在同一时刻执行多个任务。（同时执行）并发：一个CPU(采用时间片)在同一个时间段内执行多个任务。(交替执行) 1.3 什么是程序、进程、线程？
程序(program)：一段代码。静态的。
进程(process)：一个正在运行的一个程序。动态的。进程是资源分配的最小单位，有独立的内存空间，即进程中的数据存放空间（堆空间和栈空间）是独立的。
线程(thread)：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。线程堆空间是共享的（这就使得线程间通信更简便、高效。但多个线程 *** 作共享的系统资源可能就会带来安全的隐患。），栈空间是独立的，线程消耗的资源比进程小的多。
1.4 多线程编程的优点tips:
一个进程中的多个线程是并发运行的，从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()
垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。
使用单个线程先后完成多个任务（调用多个方法），比用多个线程来完成用的时间更短，但是多线程编程具有以下优点：
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。提高计算机系统CPU的利用率。改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
在程序需要同时执行两个或多个任务；程序需要实现一些需要等待的任务时，如用户输入、文件读写 *** 作、网络 *** 作、搜索等；需要一些后台运行的程序时，我们就需要多线程编程。
2 java.lang.Thread类Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread
类来实现。
public Thread():分配一个新的线程对象。public Thread(String name):分配一个指定名字的新的线程对象。public Thread(Runnable target):分配一个带有指定目标新的线程对象。public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。 2.2 Thread类的常用方法
public static Thread currentThread():返回对当前正在执行的线程对象的引用。public String getName():获取当前线程名称。
线程存在默认名称：
子线程的默认名称是：Thread-索引；
主线程的默认名称就是：main；public void setName(String name):设置该线程名称public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。public void run():此线程要执行的任务在此处定义代码。public static void yield()：线程让步。暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；若队列中没有同优先级的线程，忽略此方法。join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止（低优先级的线程也可以获得执行）stop(): 强制线程生命期结束，不推荐使用boolean isAlive()：返回boolean，判断线程是否还活着
3 Java创建线程的三种方式（重点）
3.1 继承Thread类
具体步骤：
- 定义子类继承Thread类，并重写该类的构造器（根据需求选择是否重写）以及run()方法，run()方法的方法体就代表了线程需要完成的任务,因此将其称为线程执行体。创建Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。
优缺点
优点：编码简单。
缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓展（单继承的局限性）
代码示例：
public class ThreadDemo {
// 启动后的ThreadDemo当成一个进程。
// main方法是由主线程执行的，理解成main方法就是一个主线程
public static void main(String[] args) {
// 3.创建一个线程对象
Thread t = new MyThread();
// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for(int i = 0 ; i < 10 ; i++ ){
System.out.println("main线程："+i);
}
}
}
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
// 2.重写run()方法
@Override
public void run() {
// 线程执行体
for(int i = 0 ; i < 10 ; i++ ){
System.out.println("子线程："+i);
}
}
}
运行结果：
说明：每次运行的结果都有所差异（并发随机性），也会出现某个线程全部执行完才执行另一个线程的情况。
main线程输出：0 main线程输出：1 main线程输出：2 main线程输出：3 main线程输出：4 子线程输出：0 main线程输出：5 子线程输出：1 子线程输出：2 子线程输出：3 main线程输出：6 main线程输出：7 子线程输出：4 main线程输出：8 main线程输出：9 子线程输出：5 子线程输出：6 子线程输出：7 子线程输出：8 子线程输出：9
3.2 实现Runnable接口tips：
想要启动多线程，必须调用start方法。如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式，此时将只有主线程在执行他们。start()方法底层其实是给CPU注册当前线程，并且触发run()方法执行，run()方法由JVM调用，什么时候调用，执行的过程控制都由 *** 作系统的CPU 调度决定。一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。建议线程先创建子线程，主线程的任务放在之后。否则主线程永远是先执行完！
具体步骤：
- 定义子类，实现Runnable接口，并重写该接口的run()方法。创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。调用线程对象的start()方法来启动线程。
优缺点
Runnable方式避免了单继承的局限性；实现解耦 *** 作，线程任务代码可以被多个线程共享，代码和线程独立；线程池只能放入实现Runable或Callable类线程（语法上：Thread作为Runable接口的实现类，其对象实例也能放入线程池）。但是，Runnable方式的代码与继承Thread方式相比复杂了一丢丢。
代码示例：
// 1。定义子类，实现Runnable接口
class MyRunnable implements Runnable{
// 2.重写该接口的run()方法
@Override
public void run() {
// 线程执行体
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"： "+i);
}
}
}
public class Demo {
public static void main(String[] args) {
// 3.创建自定义类对象（线程任务对象）
MyRunnable mr = new MyRunnable();
// 4.创建线程对象
Thread t = new Thread(mr, "子线程");
// 5.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程： " + i);
}
}
}
匿名内部类写法：
public class Demo {
public static void main(String[] args) {
// 1.创建自定义类对象（线程任务对象）
Runnable runnable = new Runnable() {
@Override
public void run() {
// 线程执行体
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"： "+i);
}
}
};
// 2.创建线程对象
Thread t = new Thread(runnable, "子线程");
// 3.调用线程对象的start()方法启动线程,最终还是执行run()方法
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程： " + i);
}
}
}
运行结果：
main线程： 0 子线程： 0 main线程： 1 子线程： 1 main线程： 2 子线程： 2 子线程： 3 子线程： 4 子线程： 5 main线程： 3 main线程： 4 main线程： 5 main线程： 6 main线程： 7 main线程： 8 main线程： 9 子线程： 6 子线程： 7 子线程： 8 子线程： 93.3 实现Callable接口
JDK5.0 新增线程创建方式
具体步骤：
- 定义一个线程任务类实现Callable接口 ， 申明线程执行的结果类型。重写线程任务类的call方法，这个方法可以直接返回执行的结果。创建一个Callable的线程任务对象。把Callable的线程任务对象包装成一个未来任务对象。把未来任务对象包装成线程对象。调用线程的start()方法启动线程
优缺点：
Callable方式具有Runnable方式的所有优点。除此之外，Callable方式还支持泛型的返回值、方法能抛出异常。但Callable方式的编码较为复杂。
代码示例：
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// 未来任务对象是啥，有啥用？
// 未来任务对象其实就是一个Runnable对象（底层同时实现了Runnable, Future接口）
// FutureTask既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
FutureTask task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task, "子线程");
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+": " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 1.创建一个线程任务类实现Callable接口，泛型指的是线程返回的结果类型
class MyCallable implements Callable{
// 2.重写线程任务类的call方法！
@Override
public String call() throws Exception {
// 需求：计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+": " + i);
sum+=i;
}
return Thread.currentThread().getName()+"执行的结果是："+sum;
}
}
运行结果：
main: 7 main: 8 main: 9 main: 10 子线程: 1 子线程: 2 子线程: 3 子线程: 4 子线程: 5 子线程: 6 子线程: 7 子线程: 8 子线程: 9 子线程: 10 子线程执行的结果是：553.4 总结
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
4 Java的线程调度策略同优先级线程组成先进先出队列（先到先服务），使用时间片策略对高优先级，使用优先调度的抢占式策略
线程优先级：
MAX_PRIORITY：10MIN _PRIORITY：1NORM_PRIORITY：5
涉及的方法：
getPriority()：返回线程优先值setPriority(int newPriority)：改变线程的优先级
说明：
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
Java中的线程分为两类：一种是守护线程，一种是用户线程。
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程，当前JVM将退出。 6 线程的生命周期
线程的完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的 *** 作和功能阻塞：在某种特殊情况下，被人为挂起或执行输入输出 *** 作时，让出 CPU 并临时中止自己的执行，进入阻塞状态死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
java.lang.Thread.State这个枚举类中给出了六种线程状态，与传统的五种状态一些许差异，可以通过IDEA等集成开发环境查看java源码，下面给出了源码翻译：
新建（NEW）：线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread只有线程对象，没有线程特征。可运行（RUNNABLE）：线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于 *** 作系统处理器。锁阻塞（BLOCKED）：当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。无限等待（WAITING）：一个线程在调用wait(不带参数)后会进入Waiting状态，等待另一个线程执行一个（唤醒）动作时。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。锁会释放。计时等待（TIMED_WAITING）：同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait（带参数）。锁不会释放。被终止（TERMINATED）：因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。
7 线程安全问题（重点）
7.1 什么是线程安全问题？
多个线程同时 *** 作同一个共享资源时可能会出现线程安全问题。
一个经典的例子：多个用户同时取同一个账户中的钱。
线程安全问题大多是由 全局变量 及 静态变量 引起的，局部变量逃逸也可能导致线程安全问题。
如果多线程程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，那这个程序就是线程安全的。
7.2 线程安全问题的解决方案——线程同步核心思想：让多个线程实现先后依次访问共享资源。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的 *** 作。
下面就来介绍以下java实现线程同步的三种方式。
7.2.1 同步代码块代码格式：
synchronized (同步锁对象){
// 可能会产生线程安全问题的代码
}
7.2.2 同步方法tips：
锁对象可以是任意类型。多个线程对象要使用同一把锁。锁对象建议使用共享资源。在实例方法中建议使用this作为锁对象；在静态方法中建议使用类名.class作为锁对象。锁的范围在锁住所有有安全问题的代码的前提下，越小越好。
使用synchronized修饰的方法,就叫做同步方法,保证某个线程执行该方法时,其他线程只能在方法外等着。
同步方法的原理和同步代码块的底层原理其实是完全一样的，只是同步方法是把整个方法的代码都锁起来的。
同步方法其实底层也是有锁对象的：如果方法是实例方法：同步方法默认用this作为的锁对象；如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
public synchronized void method(){
// 可能会产生线程安全问题的代码
}
7.2.3 Lock锁
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同
步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
显式加锁、释放锁。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock():加同步锁。public void unlock():释放同步锁。
代码格式：
class Demo{
private final Lock lock = new ReenTrantLock();
public void method(){
lock.lock(); // 上锁
try{
// 可能会产生线程安全问题的代码
}catch (Exception e){
e.printStackTrace();
}finally{
lock.unlock(); // 解锁
}
}
}
7.2.4 锁的选择tips：
如果同步代码有异常，要将unlock()写入finally语句块。
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）。
优先级：
Lock（拓展性好） > 同步代码块（作用范围较小） > 同步方法（作用范围较大）
释放锁的 *** 作
当前线程的同步方法、同步代码块执行结束。当前线程在同步代码块、同步方法中遇到break、return终止了该代码块的继续执行。当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的 *** 作
线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。应尽量避免使用suspend()和resume()来控制线程 8 线程的通信
线程通信实际上是一种等待唤醒机制。
核心方法 wait() 与 notify() 和 notifyAll()：
wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
9 线程池tips:
线程通信前一定要保证线程安全，否则毫无意义。这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。
背景：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间，线程也属于宝贵的系统资源。
解决方法：在Java中可以通过线程池来避免频繁创建销毁线程、实现重复利用，其实际上就是容纳了多个线程的容器。这种思想是不是非常类似于我们生活中的共享单车呢？
优势：
- 降低资源消耗。减少了创建和销毁线程的次数。提高响应速度。任务可以不需要的等到线程创建就能立即执行。提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而导致服务器挂掉。
Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。
要配置一个线程池是比较复杂的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下：
public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
获取到线程池ExecutorService 对象后，调用如下方法使用线程池对象：
public Future submit(Runnable task):获取线程池中的某一个线程对象，并执行（Future接口：用来记录线程任务执行完毕后产生的结果。）
V get() : 获取计算完成的结果。
使用线程池中线程对象的步骤：
- 创建线程池对象 Executors.newFixedThreadPool()。创建Runnable接口子类对象 new MyRunnable() 或 new MyCallable() 。(task)提交Runnable接口子类对象 submit()。(take task)关闭线程池 shutdown() 或 shutdownNow() (一般不做)。
什么是死锁？
一组进程（线程）的每一个进程（线程）都在等待一个事件，而这个事件只能由这组进程（线程）中的另一个进程（线程）引起。
出现死锁的条件：
如果在一个系统中以下四个条件同时成立，那么就能引起死锁:
- 互斥( mutual exclusion)：至少有一个资源必须处于非共享模式，即一次只有一个进程可使用。如果另一进程申请该资源，那么申请进程应等到该资源释放为止。占有并等待（hold and wait)：一个进程应占有至少一个资源，并等待另一个资源，而该资源为其他进程所占有。非抢占（no preemption)：资源不能被抢占，即资源只能被进程在完成任务后自愿释放。循环等待(circular wait)：有一组等待进程{Po,P1,…, Pn}，Po等待的资源为P1占有，P1等待的资源为P2占有，……，Pn-1等待的资源为Pn占有，Pn等待的资源为Po占有。
先要打破死锁，就需要打破上述四个条件中的其中一个或多个。
开发中应该避免死锁。
一段必然产生死锁的示例代码（死锁一般存在资源的嵌套请求）：
public class DeadLockDemo {
// 1.定义两个资源（锁对象）
public static Object resources1 = new Object();
public static Object resources2 = new Object();
public static void main(String[] args) {
// 2.创建两个线程对象
new Thread(new Runnable() {
@Override
public void run() {
// 线程1：占用资源1 ，请求资源2
synchronized (resources1){
System.out.println("线程1已经占用了资源1，开始请求资源2");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (resources2){
System.out.println("线程1已经占用了资源2");
}
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// 线程1：占用资源2 ，请求资源1
synchronized (resources2){
System.out.println("线程2已经占用了资源2，开始请求资源1");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (resources1){
System.out.println("线程2已经占用了资源1");
}
}
}
}).start();
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）