Java多线程基础用法

线程创建

线程创建的三种方式：

Thread(继承Thread类)

自定义线程类继承Thread类
重写run()方法。编写线程执行体
创建线程对象，调用start()方法启动线程

package com.lily.demo01;

public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("子线程在看代码..."+Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {

        TestThread testThread = new TestThread();
        testThread.start(); //主线程和子线程交替执行

        for (int i = 0; i < 200; i++) {
            System.out.println("主线程在看代码..."+Thread.currentThread().getName());
        }
    }
}

当调用子线程对象.run()方法其实是主线程和子线程交替执行。线程不一定立刻执行，二是由CPU根据调度算法选择调度。

Runnable(实现Runnable接口)

自定义MyRunnable实现Runnable接口
重写run方法，编写线程执行体
创建线程对象，调用start()方法启动线程

package com.lily.demo01;

public class TestThread3{

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println("子线程正在写代码"+Thread.currentThread().getName());
                }
            }
        });
        thread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程正在写代码"+Thread.currentThread().getName());
        }
    }
}

Callable(实现Callable接口)

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
提交执行：Future result = ser.submit()
获取结果：boolean r = result.get()
关闭服务：ser.shutdownNow()

package com.lily.demo01;

import java.util.concurrent.*;

public class TestThread4 implements Callable<String> {

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程正在写代码"+Thread.currentThread().getName());
        }
        return "子线程执行完毕";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个线程
        TestThread4 testThread4 = new TestThread4();
        //创建一个线程池，里有3个线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //提交执行
        Future<String> future = executorService.submit(testThread4);
        //获取结果
        String result = future.get();
        //关闭服务
        executorService.shutdown();
    }
}

关于线程常见的方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒级内让当前正在执行的线程休眠
void join()	等待线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其它线程
void interrupt()	中断线程，别用这个方法
boolean isAlive()	测试线程是否处于活动状态

关于停止线程

不推荐使用JDK提供的stop()、destroy()方法【弃用】
推荐线程自己停止下来
推荐使用一个标志位进行终止变量，当flag=false时，则终止线程运行

package com.lily.demo01;

public class TestStop {
    private static boolean flag = true;

    public static void main(String[] args) {

        int i=0;
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    if(i>100){
                        System.out.println("子线程停止运行...");
                        stop();
                        t.stop();
                    }
                    System.out.println("子线程正在运行" + Thread.currentThread().getName());
                }
            }
        });
        t.start();

        for (int j = 0; j < 20; j++) {
            System.out.println("主线程正在运行"+Thread.currentThread().getName());
        }
    }

    //设置一个公开的方法转换标志位
    public static void stop() {
        flag = false;
    }
}

线程休眠sleep

关于sleep()方法，在执行sleep()方法时，sleep不会释放锁，也就是说不会释放临界资源。

线程礼让yield

线程礼让，让当前正在执行的线程暂停，但不阻塞，从运行态转为就绪态
让CPU重新调度，但礼让不一定成功，看CPU心情

package com.lily.demo01;

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println("子线程开始执行" + Thread.currentThread().getName());
        Thread.yield(); //线程礼让
        System.out.println("子线程结束执行" + Thread.currentThread().getName());
    }
}

子线程开始执行a
子线程开始执行b
子线程结束执行a
子线程结束执行b

Process finished with exit code 0

线程强制执行join

join合并线程，待此线程执行完毕后，再执行其它线程，其它线程阻塞
可以想象成排队插队

package com.lily.demo01;

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程vip来了" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动子线程
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            if (i == 200) {
                //子线程插队
                thread.join();
            }
            System.out.println("main" + i);
        }
    }
}

观测线程状态Thread.State

在Java中，线程通常有如下状态：

NEW：就绪态
RUNNABLE：运行态
BLOCKED：阻塞态
WRITING：正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WRITING：正在等待另一个线程执行动作达到指定时间的线程处于此状态
TERMINATED：终止态

线程优先级

Java提供了一个线程调度器监控程序中启动后进入就绪状态的所有进程，线程调度器按照优先级应该调度哪个线程获取CPU资源。

现成的额优先级用数字表示，范围从1-10

Thread.MIN_PRIORITY = 1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY = 5

使用如下方法改变或获取优先级

getPriority()
setPriority(int xxx)

线程同步问题

多个线程操作同一个资源。由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁时，独占资源，其他线程必须等待，使用后释放锁即可，但存在以下问题：

一个线程持有锁会降低性能，因为别的线程需要该资源必须阻塞等待。
在多线程竞争下，加锁、释放锁会引起线程上下文切换和调度，会导致额外的资源浪费。
如果一个优先级高的线程等待一个优先级低的进程释放锁，会导致优先级倒置，引起性能问题。

两个不安全的实例

不安全的买票

package com.lily.syn;

//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();
        new Thread(station,"苦逼的我").start();
        new Thread(station,"牛逼的你们").start();
        new Thread(station,"可恶的黄牛党").start();
    }
}

class BuyTicket implements Runnable {

    //票
    private int ticketNumber = 10;
	//标志位
    private boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNumber <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName() + "买到了" + ticketNumber--);
    }
}

不安全的银行取钱

package com.lily.syn;

//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");
        you.start();
        girlFriend.start();
    }
}

//账户
class Account {
    int money;  //余额
    String name;    //卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread {
    Account account;      //账户
    int drawingMoney;     //取了多少钱
    int nowMoney;        //手里的钱

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if (account.money - drawingMoney <= 0) {
            //钱不够
            System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //取钱
        account.money -= drawingMoney;
        nowMoney += drawingMoney;
        System.out.println(account.name + "余额为:" + account.money);
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}

不安全的ArrayList

package com.lily.syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        System.out.println(list.size());
    }
}

线程同步方法

对不安全的买票实例进行修改：

class BuyTicket implements Runnable {

    //票
    private int ticketNumber = 10;

    private boolean flag = true;

    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNumber <= 0) {
            flag = false;
            return;
        }
        //买票
        System.out.println(Thread.currentThread().getName() + "买到了" + ticketNumber--);
    }
}

对不安全的银行取钱示例进行修改

package com.lily.syn;

//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        Drawing you = new Drawing(account, 50, "你");
        Drawing girlFriend = new Drawing(account, 100, "girlFriend");
        you.start();
        girlFriend.start();
    }
}

//账户
class Account {
    int money;  //余额
    String name;    //卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread {
    Account account;      //账户
    int drawingMoney;     //取了多少钱
    int nowMoney;        //手里的钱

    public Drawing(Account account, int drawingMoney, String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱
    @Override
    public void run() {

        synchronized (account) {
            //判断有没有钱
            if (account.money - drawingMoney <= 0) {
                //钱不够
                System.out.println(Thread.currentThread().getName() + "钱不够,取不了");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //取钱
            account.money -= drawingMoney;
            nowMoney += drawingMoney;
            System.out.println(account.name + "余额为:" + account.money);
            System.out.println(this.getName() + "手里的钱" + nowMoney);
        }
    }
}

对不安全的集合进行修改

package com.lily.syn;

import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (list) {
                        list.add(Thread.currentThread().getName());
                    }
                }
            }).start();
        }
        System.out.println(list.size());
    }
}

Lock锁

从JDK5.O开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
锁提供了对共享资源的独占访问每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获取锁。
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

package com.lily.syn;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2, "SubThread1").start();
        new Thread(testLock2, "SubThread2").start();
        new Thread(testLock2, "SubThread3").start();
    }
}

class TestLock2 implements Runnable {

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    private int tickerNumer = 10;

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();    //加锁
                if (tickerNumer > 0) {
                    System.out.println("当前" + Thread.currentThread().getName() + "抢到了票,还剩票数:" + tickerNumer--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();  //解锁，释放资源
            }
        }
    }
}

关于Lock和synchronized比较

Lock锁是显式锁（手动开启和关闭），synchronized是隐式锁，出了作用域自动释放。
Lock只有代码块锁，synchronized有代码块锁和方法锁。
使用Lock锁，JVM将花费少量的时间调度线程，性能更好，并且具有更好的扩展性。
优先使用顺序：Lock > 同步代码块 > 同步方法。

线程池

由于经常创建和消耗线程，会造成比较大的资源浪费，对性能有较大影响，因此提出线程池的概念。

提前创建好多个线程，放入线程池中，使用时直接获取，用完之后放回线程池中，可以避免的创建、销毁线程。实现重复利用。

好处：

提高响应速度（减少了创建线程的时间）
降低资源消耗
便于管理
- corePoolSize:核心池大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止

JDK5.0起提供了两种线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor

void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task):执行任务，有返回值，返回值为T，一般用来执行Callable

Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

package com.lily.syn;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //创建线程池,里面有10个线程(进程池大小)
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyThrad());
        service.execute(new MyThrad());
        service.execute(new MyThrad());
        service.execute(new MyThrad());
        service.execute(new MyThrad());
        //关闭连接
        service.shutdown();
    }
}

class MyThrad implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

pool-1-thread-2
pool-1-thread-5
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4

Process finished with exit code 0

posted @ 2024-03-11 16:39 LilyFlower 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 1_JAVA线程

· 5_运行时数据区概述

· JAVA线程的学习

· 多线程基础知识！！！

· 回顾多线程

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

公告

昵称： LilyFlower
园龄： 3年10个月
粉丝： 9
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

Lily Flower