文章目录
程序，进程，线程的基本概念
- 程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
- 进程（process）是程序的一次执行代码，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 如：运行中的QQ
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的区域
- 线程（thread），进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程，就是支持多线程的
- 线程作为调度和执行单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间->同门从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
- 并行和并发：
并行：多个CPU同时执行多个任务。比如多个人同时做不同的事。
并发：一个CPU同时执行多个任务。
多线程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
为什么需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
创建一个多线程
方式一：继承Thread
- 创建一个继承于Thread类的子类
- 重写Thread类的run（）–>将此线程执行的操作声明在run（）中
- 创建Thread类的子类对象
- 调用此对象start（）
start方法的作用：
1）启动一个线程；
2）调用此线程的run方法
class TreadTest{
static class Tread_1 extends Thread{
public void run(){
for(int i = 0;i<10000;i++){
if(i%2==0)
System.out.println(Thread.currentThread().getName()+factorial(i));
}
}
}
public static void main(String[] args){
// int i = 10;
// System.out.println(factorial(i));
Tread_1 thread = new Tread_1();
thread.start(); // start方法的作用：1.启动一个线程；2.调用此线程的run方法
for(int i=0;i<10000;i++){
if(i%2==0)
System.out.println(Thread.currentThread().getName()+factorial(i));
}
new Thread(){public void run(){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}}.start(); //匿名对象
}
static int factorial(int i){
if(i<=1)
{return 1;}
else
{return i*factorial(i-1);}
}
}
方式二：实现Runable接口
- 创建一个实现了Runable接口的类
- 实现类去实现Runable中的抽象方法：run（）
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start（）
RunThread thread1 = new RunThread();
new Thread(thread1,"thread1").start(); // 调用线程
class RunThread implements Runnable{
public int x=1000;
public void run(){
// for(int i=0;i<3000;i++){
// if(x>=0){
// System.out.println(Thread.currentThread().getName()+" "+ x--);
//
// }
// }
while(x>0){
System.out.println(Thread.currentThread().getName()+" "+ x--);
}
}
}
两种方式对比
开发中：优先选择，实现Runable接口的方法
原因：1.）实现的方法不会存在 类的单继承的局限性。2）实现的方式更适合来处理多个线程共享数据的情况
两种方式的相同点：两种方式都要重写run（），将线程要执行的逻辑声明在run（）中。目前的两种方式，要想启动线程，都是调用Thread类中的start（）
新增方式一：实现Callable接口
-
相比run()方法，可以有返回值
-
方法可以抛出异常
-
支持泛型的返回值
-
需要借助FutureTask类，比如获取返回结果
Future接口
- 可以对具体Runable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutureTask是Future接口的唯一的实现类
- FutureTask同时实现了Runnable，Future接口，它既可以作为Runable被线程执行，又可以作为Futurede得到Callable的返回值。
代码示例：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
* 1. call()可以有返回值的。
* 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
* 3. Callable是支持泛型的
*
* @author shkstart
* @create 2019-02-15 下午 6:01
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
新增方式二：使用线程池
为什么使用线程池创建线程？
-
背景：经常创建和销毁、使用量特别大的资源，比如并发下的线程，对性能影响很大。
-
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的接通工具
-
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后静止。
如何创建线程池
package com.atguigu.interview;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//创建并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
ExecutorService pool = Executors.newFixedThreadPool(10);
// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
// 并执行相关的run()
pool.execute(new MyThread());
pool.execute(new MyThread());
pool.execute(new MyThread());
// 3.结束线程的使用
pool.shutdown();
}
}
测试Thread中的常用方法
- start()：启动当前线程；调用当前线程的run（）
- run（）：Tsingtao需要重写Thread中的方法，创建线程的操作需要写在这里。
- currentTread()：静态方法，返回执行当前代码的线程（应该是地址）
- getName（）：获取当前线程的名字
- setName（）：设置当前线程的名字
- yield(): 线程执行此方法时，释放当前cpu的执行权
- join（）: thread1.join()，在某个线程中调用另外一个线程中的join方法，此时某线程处于阻塞状态，则开始执行这个线程直到执行完毕，接下来继续执行某线程。
- stop（）：（已过时）强制线程生命周期结束。
- sleep（long millitime）:线程休眠一段时间。指定的时间内，当前线程是阻塞状态。
- isAlive（）：判断某个线程是否在执行
线程的优先级
线程优先级的数值只是概率，并不是优先级数值越大执行优先级就一定高，也不是说高优先级的线程执行完低优先级的线程才会执行。
- 相关常量
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 - 如何获取当前线程的优先级
- getPriority(): 获取线程的优先级
- setPriority(int p) ：设置线程的优先级
线程通信
wait（）/ notify（）/ notifyAll（）：此三个方法定义在Object类中
线程的分类：
java线程分为两类：一种是守护线程，一种是用户线程。
- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的，通过在start（）方法前调用thread.setDaemon(true)可以把一个用户线程变成守护线程。
- java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程，当前JVM将推出
线程的生命周期：
线程的同步
方式一：synchronized同步代码块
synchronized(同步监视器){
需要同步的代码
}
- 操作共享数据的代码，即为需要被同步的代码。
- 共享数据：多个新城共同操作的变量
- 同步监视器：俗称，锁。任何一个类的对象，都可以充当锁。要求：多个线程必须共用一把锁。
补充：在实现Runable接口创建的多线程方式中，我们可以考虑使用this充当同步监视器。（因为用Runable接口实现的方式，多个线程一般共用此类，所以this为同一个this）
class Singleton{
private Singleton(){}
private static Singleton instan = null;
// 同步代码块的方式实施线程安全
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (instan == null) {
return new Singleton();
}
return instan;
}
}
}
方式二：synchronized同步方法
如果操作共享数据的代码完整的声明在一个车方法中，我们可以将此方法声明为同步的。
class Singleton{
private Singleton(){}
private static Singleton instan = null;
// 同步方法的方式实施线程安全
public static synchronized Singleton getInstance(){
if (instan == null){
return new Singleton();
}else{
return instan;
}
}
}
同步方式的优缺点
优势：解决了线程安全的问题
劣势：操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。
关于同步的总结
- 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
- 非静态的同步方法，同步监视器是：this
- 静态的同步方法，同步监视器是：当前类本身
释放安全锁和不释放安全锁的操作：
释放安全锁的操作：
不释放安全锁的操作：
死锁的问题
- 死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 说明：
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
- 我们使用同步时，要避免出现死锁
死锁代码示例：
package dead_lock;
class A {
public synchronized void foo(B b) { // 同步监视器（锁）是对象A
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了A实例的foo方法"); // ①
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用B实例的last方法"); // ③
b.last(); // 需要先有A然后有B的锁才能运行，运行完才能释放A的锁
}
public synchronized void last() { // 同步监视器（锁）:对象A
System.out.println("进入了A类的last方法内部");
}
}
class B {
public synchronized void bar(A a) { // 同步监视器（锁）:对象B
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了B实例的bar方法"); // ②
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用A实例的last方法"); // ④
a.last();
}
public synchronized void last() { // 同步监视器（锁）:对象B
System.out.println("进入了B类的last方法内部");
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
Thread.currentThread().setName("主线程");
// 调用a对象的foo方法
a.foo(b);
System.out.println("进入了主线程之后");
}
public void run() {
Thread.currentThread().setName("副线程");
// 调用b对象的bar方法
b.bar(a);
System.out.println("进入了副线程之后");
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
new Thread(dl).start(); // 线程一：运行run()方法
dl.init(); // 主线程：运行init()方法
}
}
通过Lock锁来解决线程安全问题
ReentrantLock lock = new ReentrantLock()
lock.lock();
// 同步代码
lock.unlock();
snchronized和Lock的异同？
- 相同：二者都可以解决线程安全问题
- 不同：synchronized机制在执行完相应的同步代码以后，自动释放同步监视器，Lock需要手动的启动同步（Lock（）)，同时结束同步也需要手动实现（unlock()）。
线程的通信：
- wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放多个监视器。
- notify()：一旦执行此方法，就会唤醒被- wait()的一个线程。如果有多个线程被wait,就唤醒优先级高的
- notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程
注意：
- wait(),notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
- wait(),notify(),notifyAll()三个方法的调用者必须是
同步代码块或同步方法中的同步监视器。否则会报IllegalMonitorStateException异常。
sleep()和wait()方法的异同？
- 相同点，一旦执行方法，都可以使得当前线程进入阻塞状态
- 不同点：
1）两个方法声明的位置不同：Thread类中声明sleep（），object类中声明wait（）
2）调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
3）如果两个方法都是用在同步代码块或同步方法中，sleep（）不会释放同步监视器，wait()会释放同步监视器。
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
