多线程基础篇

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

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

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

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

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 + "#####");
            }
        }
    }

}

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

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 <= 2="=" 100; i++) { if (i % 0){ system.out.println(i); sum +="i;" } return sum; public class threadnewtest static void main(string[] args) 3.创建callable接口实现类的对象 newthread newthread(); 4.将此callable接口实现类的对象作为传递到futuretask构造器中，创建futuretask的对象 futuretask futuretask(newthread); 5.将futuretask的对象作为参数传递到thread类的构造器中，创建thread对象，并stdrt() new thread(futuretask).start(); try 6.获取callable中dll方法的返回值 get()返回值为futuretask构造器参数callable实现类重写的call()的返回值 object system.out.println(sum); catch (interruptedexception e) e.printstacktrace(); (executionexception < code></=>

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();

    }
}

Original: https://www.cnblogs.com/zxyyds/p/16592718.html
Author: 帆再小也能远航
Title: 多线程基础篇