Java多线程

关注

原创最新推荐文章于 2026-03-21 01:13:58 发布 157 阅读 AI 写同款· GEO 优化 ›

JAVA多线程详解（超详细）程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。阅读详情

（一）线程的概念及使用

线程：在同一个程序中，同时运行多个独立的流程，每一个独立的流程就是一个线程
线程并发：一个程序中，多个线程并发执行
主线程：但JVM启动后，加载类文件，发现main方法，为main方法创建一个线程，用于main方法执行，这个main创建的线程为主线程
java中实现自定义线程类的方法：
继承java.lang.Thread类
实现java.lang.Runnable接口
继承Thread类：
自定义一个线程类继承Thread
重写Thread的run方法
创建自定义线程类对象
开启线程：调用自定义线程类的start方法

继承Thread类练习

ThreadADemo

package com.thread;

public class ThreadADemo extends Thread{
    @Override
    public void run(){
        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

ThreadBDemo

package com.thread;

public class ThreadBDemo extends Thread{
    @Override
    public void run(){
        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

MainDemo

package com.thread;

public class MainDemo {
    public static void main(String[] args) {
        /*
        * 自定义线程类
        *1.继承Thread类
        * 2.重写run方法
        * 3.创建自定义线程类对象
        * 4.开启线程：调用Start()方法
        * */

        ThreadADemo threadADemo = new ThreadADemo();
        threadADemo.start();

        ThreadBDemo threadBDemo = new ThreadBDemo();
        threadBDemo.start();

        /*主线程JVM*/
        for (int i = 0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }

        /*输出结果
        * main	0 一直到  main	99
        * Thread-0	0 一直到  Thread-0	99
        * Thread-1	0 一直到  Thread-1	99
        * */
     }
}

实现Runnable接口：
自定义一个线程类实现Runnable接口
重写Runnable的run方法
创建自定义线程类对象，并传入Thread对象中
开启线程，调用自定义线程的start（）方法

实现Runnable接口练习

ThreadADemo

package com.thread2;

public class ThreadADemo implements Runnable{
    @Override
    public void run(){
        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

ThreadBDemo

package com.thread2;

public class ThreadBDemo implements Runnable{
    @Override
    public void run(){
        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

MainDemo

package com.thread2;

public class MainDemo {
    public static void main(String[] args) {
        /*
        * 自定义线程类
        *1.继承Thread类
        * 2.重写run方法
        * 3.创建自定义线程类对象
        * 4.开启线程：调用Start()方法
        * */

        ThreadADemo threadADemo = new ThreadADemo();
        ThreadBDemo threadBDemo = new ThreadBDemo();

        Thread thread1 = new Thread(threadADemo);
        Thread thread2 = new Thread(threadBDemo);
        thread1.start();;
        thread2.start();


        /*主线程JVM*/
        for (int i = 0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }

        /*输出结果
        * main	0 一直到  main	99
        * Thread-0	0 一直到  Thread-0	99
        * Thread-1	0 一直到  Thread-1	99
        * */
     }
}

（二）线程的状态

在这里插入图片描述

新建状态
可运行状态
阻塞状态
运行状态
死亡状态

1.阻塞状态

Thread的void sleep（long millis）方法用于使当前线程休眠指定的毫秒数,代码如下：

ThreadADemo

package com.thread3;

public class ThreadADemo extends Thread{


    @Override
    public void run(){

        try {
            sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

ThreadBDemo

package com.thread3;

public class ThreadBDemo implements Runnable{

    @Override
    public void run(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i =0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);//获取当前线程名字
        }
    }
}

sleep方法对线程的控制是十分不精确的
join可以精确控制线程，也会导致线程阻塞
join特点：如果当前线程调用了另外一个线程的join方法，当前线程会立即阻塞，直到另外一个线程运行完成
关于join的代码如下：

ThreadADemo

package com.thread5;

public class ThreadADemo extends Thread{
    private Thread thread;
    public ThreadADemo(Thread thread){
        super();
        this.thread = thread;
    }

    @Override
    public void run(){
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
            System.out.println(Thread.currentThread().getName()+"\t"+"我是线程A");//获取当前线程名字
    }
}

ThreadBDemo

package com.thread5;

public class ThreadBDemo extends Thread{
    @Override
    public void run(){

            System.out.println(Thread.currentThread().getName()+"\t"+"我是线程B");//获取当前线程名字

    }
}

MainDemo

package com.thread5;

public class MainDemo {
    public static void main(String[] args) {

        ThreadBDemo threadBDemo = new ThreadBDemo();
        ThreadADemo threadADemo = new ThreadADemo(threadBDemo);

        threadADemo.start();
        threadBDemo.start();

        /*输出结果
        * Thread-0 我是线程B
        * Thread-1 我是线程A
        * */
     }
}

join的阻塞问题：相互等对方完成，相关代码如下：

ThreadADemo

package com.thread6;

public class ThreadADemo extends Thread{
     Thread threadB;

    @Override
    public void run(){
        try {
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0 ; i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }
}

ThreadBDemo

package com.thread6;

public class ThreadBDemo extends Thread{
    Thread threadA;

    @Override
    public void run(){
        try {
            threadA.join(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0 ; i<100;i++){
            System.out.println(Thread.currentThread().getName()+"\t"+i);
        }
    }
}

MainDemo

package com.thread6;

public class MainDemo {
    public static void main(String[] args) {

        ThreadBDemo threadBDemo = new ThreadBDemo();
        ThreadADemo threadADemo = new ThreadADemo();

        threadADemo.threadB = threadBDemo;
        threadBDemo.threadA  = threadADemo;
        threadADemo.start();
        threadBDemo.start();
     }
     /*输出结果
     * Thread-0    0 到Thread-0    99
     * Thread-1    0 到Thread-1    99
     * */
}

（三）线程同步

被多个线程并发访问时，如果一个对象有可能出现数据不一致问题，那么这个对象称为线程不安全的对象,代码实例如下：

Account

package com.thread7;


public class Account {
    private double blanace ;

    public Account(double blanace) {
        this.blanace = blanace;
    }

    public void cun(double blanace){
        System.out.println("存款前的余额"+this.blanace);
        blanace += blanace;
        System.out.println("存款后的余额");
    }

    public  void qu(double blanace){
        System.out.println("取款前的余额"+this.blanace);
        if (this.blanace>blanace){
            this.blanace -=blanace;
            System.out.println("取款后的余额"+this.blanace);
        }else{
            System.out.println("余额不足");
        }
    }

}

PersonA

package com.thread7;

public class PersonA  extends  Thread{
    private Account account;

    public PersonA(Account account) {
        this.account = account;
    }

    @Override
    public void run(){
        for (int i = 0 ; i<5 ; i++){
            account.cun(500);
        }
    }
}

PersonB

package com.thread7;

public class PersonB  extends  Thread{
    private Account account;

    public PersonB(Account account) {
        this.account = account;
    }

    @Override
    public void run(){
        for (int i = 0 ; i<5 ; i++){
            account.qu(1000);
        }
    }
}

主方法

package com.thread7;

public class Test {
    public static void main(String[] args) {
        Account account = new Account(10000);
        PersonA personA = new PersonA(account);
        PersonB personB = new PersonB(account);

        personA.start();
        personB.start();
    }
}
/*输出结果
            存款前的余额10000.0
            存款后的余额
            取款前的余额10000.0
            存款前的余额10000.0
            存款后的余额
            存款前的余额9000.0
            存款后的余额
            存款前的余额9000.0
            存款后的余额
            存款前的余额9000.0
            存款后的余额
            取款后的余额9000.0
            取款前的余额9000.0
            取款后的余额8000.0
            取款前的余额8000.0
            取款后的余额7000.0
            取款前的余额7000.0
            取款后的余额6000.0
            取款前的余额6000.0
            取款后的余额5000.0

* */

synchronized同步代码块
格式：synchronized（对象）{
同步的代码
}
同步可以解决安全问题的根本原因，就在那个对象上。该对象如同锁的功能，示例代码如下

package com.thread7;


public class Account2 {
    private double blanace ;
    Object object = new Object();//创建对象

    public Account2(double blanace) {
        this.blanace = blanace;
    }

    public void cun(double blanace){
        //使用同步
        synchronized (object){
            System.out.println("存款前的余额"+this.blanace);
            blanace += blanace;
            System.out.println("存款后的余额");
        }
    }

    public  void qu(double blanace){
        synchronized (object){
            System.out.println("取款前的余额"+this.blanace);
            if (this.blanace>blanace){
                this.blanace -=blanace;
                System.out.println("取款后的余额"+this.blanace);
            }else{
                System.out.println("余额不足");
            }
        }
    }

}

同步方法：在函数上加上synchronized修饰即可。
格式:[修饰符] synchronized 返回值类型方法名（参数列表） {}，示例代码如下：

package com.thread7;


public class Account3 {
    private double blanace ;

    public Account3(double blanace) {
        this.blanace = blanace;
    }

    public synchronized void cun(double blanace){ //定义为同步方法
        System.out.println("存款前的余额"+this.blanace);
        blanace += blanace;
        System.out.println("存款后的余额");
    }

    public synchronized  void qu(double blanace){//定义为同步方法
        System.out.println("取款前的余额"+this.blanace);
        if (this.blanace>blanace){
            this.blanace -=blanace;
            System.out.println("取款后的余额"+this.blanace);
        }else{
            System.out.println("余额不足");
        }
    }

}

（四)线程通信

线程死锁

代码示例:

ThreadA

package com.thread9;

public class ThreadA extends Thread {
    private Object a;
    private  Object b;

    public ThreadA(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public void run(){
        System.out.println("ThreadA开始获取对象a的锁");
        synchronized (a){
            System.out.println("ThreadA开始获取对象b的锁");
            synchronized (b){

            }
            System.out.println("ThreadA释放对象b的锁");
        }
        System.out.println("ThreadA释放对象a的锁");
    }
}

ThreadB

package com.thread9;

public class ThreadB extends Thread {
    private Object a;
    private  Object b;

    public ThreadB(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public void run(){
        System.out.println("开始获取对象b的锁");
        synchronized (b){
            System.out.println("开始获取对象a的锁");
            synchronized (a){

            }
            System.out.println("释放对象a的锁");
        }
        System.out.println("释放对象b的锁");
    }
}

Test

package com.thread9;

public class Test {
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        ThreadA threadA = new ThreadA(a,b);
        ThreadB threadB = new ThreadB(a,b);

        threadA.start();
        threadB.start();
    }
}
/*ThreadA开始获取对象a的锁
开始获取对象b的锁
开始获取对象a的锁
释放对象a的锁
ThreadA开始获取对象b的锁
释放对象b的锁
ThreadA释放对象b的锁
ThreadA释放对象a的锁*/

线程死锁解决：wait和notify,代码如下：

ThreadA

package com.thread10;

public class ThreadA extends Thread {
    private Object a;
    private  Object b;

    public ThreadA(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public void run(){
        System.out.println("ThreadA开始获取对象a的锁");
        synchronized (a){
            try {
                a.wait();
                sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA开始获取对象b的锁");
            synchronized (b){

            }
            System.out.println("ThreadA释放对象b的锁");
        }
        System.out.println("ThreadA释放对象a的锁");
    }
}

ThreadB

package com.thread10;

public class ThreadB extends Thread {
    private Object a;
    private  Object b;

    public ThreadB(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public void run(){
        System.out.println("开始获取对象b的锁");
        synchronized (b){
            System.out.println("开始获取对象a的锁");
            synchronized (a){
                a.notify();
            }
            System.out.println("释放对象a的锁");
        }
        System.out.println("释放对象b的锁");
    }
}

线程通信：数据紊乱

package com.thread11;

public class Res {
    String name;
    String sex;
}

Input

package com.thread11;

public class Input implements Runnable{
    private Res res;

    public Input(Res res) {
        this.res = res;
    }
    @Override
    public void run() {
        int x = 0;
        while (true){
            if (x == 0){
                res.name = "杰克";
                res.sex = "男";
            }else {
                res.name = "肉丝";
                res.sex = "女";
            }
            x = (x+1)%2;
        }
    }
}

Output

package com.thread11;

public class Output implements Runnable{

    private Res res;

    public Output(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true){
            System.out.println(res.sex+"  "+res.name);
        }
    }
}

数据紊乱同步代码块，代码示例如下

Input

package com.thread12;

import com.thread11.Res;

public class Input implements Runnable{
    private Res res;

    public Input(Res res) {
        this.res = res;
    }
    @Override
    public void run() {
       synchronized (Input.class){
           int x = 0;
           while (true){
               if (x == 0){
                   res.name = "杰克";
                   res.sex = "男";
               }else {
                   res.name = "肉丝";
                   res.sex = "女";
               }
           }
       }
    }
}

Output

package com.thread12;

import com.thread11.Res;

public class Output implements Runnable{

    private Res res;

    public Output(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true){
            synchronized (Input.class){
                System.out.println(res.sex+"  "+res.name);
            }
        }
    }
}

数据紊乱解决方案：

res

package com.thread13;

public class Res {
    String name;
    String sex;
   boolean flag = false;
}

Input

package com.thread13;

import com.thread13.Res;

public class Input implements Runnable{
    private Res res;

    public Input(Res res) {
        this.res = res;
    }
    @Override
    public void run() {
        int x = 0;
        while (true){
            synchronized (res){
                if (res.flag){
                    try {
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (x == 0){
                    res.name = "杰克";
                    res.sex = "男";
                }else {
                    res.name = "肉丝";
                    res.sex = "女";
                }
                x = (x+1)%2;
                res.flag = true;
                res.notify();
            }
        }

    }
}

Output

package com.thread13;

import com.thread13.Res;

public class Output implements Runnable{

    private Res res;

    public Output(Res res) {
        this.res = res;
    }

    @Override
    public void run() {
        while (true){
            synchronized (res){
                if (!res.flag){
                    try {
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(res.sex+"  "+res.name);
                res.flag = false;
                res.notify();
            }
        }
    }
}

收录于