多线程基础篇

多线程

目录

• 基本概念 (程序，进程，线程)
• 线程的创建和使用
• 线程的生命周期
• 线程的同步
• 线程的通信
• JDK5.0新增线程创建方式

程序 (program)：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程 (process)：程序的一次执行过程，或是正在运行的一个程序。
是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期。
·如：运行中的 QQ，运行中的 MP3 播放器程序是静态的，进程是动态的。
·进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区
域

线程 (thread)：进程可进一步细化为线程，是一个程序内部的一条执
行路径。
·若一个进程同一时间并行执行多个线程，就是支持多线程的。
·线程是调度和执行的单位，每个线程拥有独立的运行栈和程序计数器 (pc)，
线程切换的开销小。
·一个进程中的多个线程共享相同的内存单元 / 内存地址空间—》它们从同
一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、
高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

多线程的创建，方式一:继承于Thread类

1.创建一个基础Thread类的子类*

2.重写Thread类的run()*

3.创建Thread类的子类的对象*

4.通过此对象调用start()*

例子：遍历100以内的所有偶数

class MyThread extends Thread {

    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+i);
            }
        }

    }

}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();//通过调用此对象的start方法:1.启动当前线程，2调用当前线程的run()
        MyThread myThread2 = new MyThread();
        myThread2.start();
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i + "#####");
            }
        }
    }

}

创建多线程的方式二:实现Runnable接口

1.创建一个实现了Runnable接口的类

2.实现类去实现Runnable中的抽象方法:run()

3.创建实现类的对象

4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

5．通过Thread类的对象调用start()

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        MThread mThread = new MThread();
        new Thread(mThread).start();
    }

}

---

/**
 * @deprecated
 * 测试Thread中常用的方法:
 * 1.start():启动当前线程:调用当前线程的run()；
 * 2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
 * 3.currentThread():静态方法，返回执行当前代码的线程
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 * 6.yield():释放当前cpu的执行权
 * 7.join():线程插队，谁调用谁插队，在线程a中调用b的join，a进入阻塞状态，b获取执行权，
 * b执行完以后，a才结束阻塞状态，等待cpu分配资源
 * 8.stop():强制结束声明周期，不推荐使用
 * 9.sleep(long millitime):让当前线程睡眠指定时间，指定时间内，当前线程为阻塞状态
 * 10.isAlive():判断当前线程是否还存活
 *
 *
 * 线程的优先级:
 * 1.
 * MAX_PRIORITY :10
 * MIN_PRIORITY :1
 * NORM_PRIORITY :5
 * 2.如何获取和设置线程的优先级
 * getPriority()和setPriority()
 * 说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。
 * 并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
 *
 *
 * @author zx
 * @create 2022-08-14 21:09
 */

开发中:优先选择:实现Runnable接口的方式原因:

实现的方式没有类的单继承性的局限性

实现的方式更适合来处理多个线程有共享数据的情况。

联系: public class Thread implements Runnable

相同点:两种方式都需要重写run( ),将线程要执行的逻辑声明在run( )中。

进程可以细化为多个线程。

每个线程，拥有自己独立的:栈、程序计数器

多个线程，共享同一个进程中的结构:方法区、堆。

---

线程的生命周期

1、新建状态（New）：新创建了一个线程对象。 
2、就绪状态（Runnable）：也叫可运行状态。线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种： 
①等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。 
②同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。 
③其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。 
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程的安全问题

方法一:同步代码块
      synchronized(同步监视器){
      //需要被同步的代码
      }
      说明:
      1操作共享数据的代码,即为需要被同步的代码
      2共享数据:多个线程共同操作的变量
      3同步监视器,俗称:锁。任何一个类的对象，都可以充当锁
      要求:多个线程必须要共用同一把锁
          
方法二:同步方法
    
    
    同步的方式，解决了线程的安全问题。---好处
    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---局限性

---

单例模式懒汉式线程安全

package com.zx.java1;

/**
 * @author zx
 * @create 2022-08-15 18:11
 */
public class BankTest {
}

class Bank {
    public Bank() {

    }

    private static Bank instance = null;

    public static Bank getInstance() {
        //方法一:
        /*synchronized (Bank.class) {
            if (instance == null) {
                instance = new Bank();
            }
        }
        return instance;*/
        //方法二:效率更高
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }

}

经典面试题

synchronized 和 lock的异同
相同:二者都可以解决线程安全问题
不同:synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
    Lock需要手动的启动同步(Lock())，同时结束同步也需要手动的实现(unlock())

如何解决线程安全问题?有几种方式
有三种,分别是synchronized修饰的方法，synchronized的代码块，还有JDK5.0之后的lock的使用

线程的通信

线程通信的例子：使用两个线程打印1-100。线程1，线程2 交替打印
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
 * notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个wait，就换醒优先级高的那个线程
 * notifyAll(): 一旦执行此方法，就会唤醒所有被wait()的线程
 
 class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                //唤醒被wait的线程
                notify();
                if (number <= 1000){
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        //使得调用如下wait方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }

    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        new Thread(number,"线程1").start();
        new Thread(number,"线程2").start();
    }
}


说明:1.wait( )，notify()，notifyALl()三个方法必须使用在同步代码块或同步方法中。
    2.wait( )，notify( )，notifyALL()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。

---

经典面试题

sleep() 和 wait() 有什么区别?
sleep就是暂停当前线程一段时间，把cpu让给其他线程使用，到时后会自动恢复。调用sleep不会释放对象锁。 wait方法导致本线程放弃对象锁，进入等待，只有等到本对象的notify方法（或notifyAll）后本线程才进入就绪状态，等待执行
wait()必须使用在同步代码块或同步方法中，sleep()可以在任何需要的场景下调用

---

创建线程的方式三

package com.zx.java2;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
 * 1. calL()可以有返回值的。
 * 2. caLL()可以抛出异常，被外面的操作捕获，获取异常的信息
 * 3. calLable是支持泛型的
 * @author zx
 * @create 2022-08-16 17:32
 *
 */
//1.创建一个实现Callable的实现类
class NewThread implements Callable {

    @Override
    //2.实现caLl方法，将此线程需要执行的操作声明在call()中
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNewTest {
    public static void main(String[] args) {
        //3.创建CallabLe接口实现类的对象
        NewThread newThread = new NewThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(newThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并stdrt()
        new Thread(futureTask).start();


        try {
            //6.获取callable中dlL方法的返回值
            //get()返回值为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

}

---

创建线程的方式四

package com.zx.java2;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 创建线程的方式4:使用线程池
 * 好处：降低资源消耗（重复利用线程池中线程，不需要每次都创建)
 * 便于线程管理
 * 提高响应速度（减少了创建新线程的时间)
 *
 * @author zx
 * @create 2022-08-16 19:01
 */

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

class NumberThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() +"----" + i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //2.执行指定的线程的操作。需要提供实现Runnable接口或callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread2());
        //service.submit();适用于Callable
        
        //3.关闭连接池
        service.shutdown();

    }
}