Java：认识多线程

Breeze.

发布于 2022-06-05 04:16:17

23200

代码可运行

文章被收录于专栏：一只无聊的清风一只无聊的清风

运行总次数：0

代码可运行

概述

什么是线程？？？

进程的概念：进程是指可执行程序并存放在计算机存储器的一个指令序列，他是一个动态执行的过程。进程的概念和特征_C语言中文网 (biancheng.net) 线程是比进程还要小的运行单位，一个进程含多个线程

Thread类和Runnable接口介绍

线程创建

创建一个Thread类，或者一个Thread子类的对象
创建一个实现Runnable接口的类的对象

Thread类

Thread是一个线程类，位于java.lang包下

Thread类的常用方法

Runnable接口

只有一个run();
Runnable是Java中用以实现线程的接口

线程创建

通过Thread类创建线程

class MyThread extends Thread{
    public void run(){
        System.out.println(getName()+"该线程正在执行！");
    }
}
/**
 * 线程是随机运行的且只能调用一次start方法。
 * 多次调用会报异常 java.lang.IllegalThreadStateException
 */
public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("主线程1");
        MyThread mt=new MyThread();
        mt.start();//调用start启动线程
        System.out.println("主线程2");
    }
}

class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    public void run(){
        for (int i=1;i<=10;i++){
            System.out.println(getName()+"该线程已运行"+i+"次");
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread mt1=new MyThread("线程1");
        mt1.start();
        MyThread mt2=new MyThread("线程2");
        mt2.start();
    }
}

通过Runnable接口的方式创建

为什么要实现Runnable接口？
- Java不支持多继承
- 不打算重写Thread类其他的方法

Runnable是接口不能直接调用Thread类的方法

/**
 * 用Thread类调用currentThread()也就是当前线程，再去调用getName()方法
 */
class PrintRunnable implements Runnable{
    @Override
    public void run(){
        int i=1;
        while(i<=5) {
            System.out.println(Thread.currentThread().getName() + "正在运行"+(i++));
        }
    }
}

/**
 * 此处不能直接调用strat方法，因为根本没有此方法
 */
public class Test {
    public static void main(String[] args) {
        PrintRunnable pr=new PrintRunnable();
        Thread t1=new Thread(pr);
        t1.start();
        PrintRunnable pr1=new PrintRunnable();
        Thread t2=new Thread(pr1);
        t2.start();
    }
}

class PrintRunnable implements Runnable{
    int i=1;
    @Override
    public void run(){
        while(i<=5) {
            System.out.println(Thread.currentThread().getName() + "正在运行"+(i++));
        }
    }
}

public class Test {
    public static void main(String[] args) {
        /**
         * 此时定义的int i=1; 相当于一个资源被t1和t2共享，
         * 这种情况适合多个线程处理同一个资源
         */
        PrintRunnable pr=new PrintRunnable();
        Thread t1=new Thread(pr);
        t1.start();
//        PrintRunnable pr1=new PrintRunnable();
        Thread t2=new Thread(pr);
        t2.start();
    }
}

线程的生命周期

线程状态

新建状态（New）
可运行状态（Runnable）
正在运行（Running）
阻塞（Blocked）
终止（Dead）

sleep方法应用

Thread类的方法
- public static void sleep(long millis)
作用：在指定的毫秒数内让正在执行的线程休眠（暂停执行）
参数为休眠的时间，单位是毫秒

class MyThread implements Runnable{
    public void run(){
        for (int i = 1; i <=15 ; i++) {
            System.out.println(Thread.currentThread().getName()+"运行了"+i+"次");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class SleepDemo {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread t=new Thread(mt);
        t.start();
    }
}

join方法应用

Thread类的方法
- public final void join()
作用：等待调用该方法的线程结束后才能执行
- public final void join(long millis)
作用：等待该线程终止的最长等待时间为milli毫秒

class MyThread extends Thread{
    public void run(){
        for (int i = 1; i < 400; i++) {
            System.out.println(getName()+"正在执行"+i+"次");
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        mt.start();
        try {
            mt.join(1);//不管运行多少次，在1毫秒后都会停止
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for (int i=1;i<10;i++){
            System.out.println("主线程运行第"+i+"次");
        }
        System.out.println("主线程结束");
    }
}

线程优先级

Java为线程类提供了10个优先级
优先级可以用整数1-10表示，超出这个范围会抛出异常
作为main方法主线程默认优先级为5
优先级常量
1. MAX_PRIORITY：线程的最高优先级10
2. MIN_PRIORITY：线程的最低优先级1
3. NORM_PRIORITY：线程的默认优先级5
优先级相关方法

class MyThread extends Thread{
    private  String name;
    public MyThread(String name){
        this.name=name;
    }

    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println("线程"+name+"正在运行"+i);
        }
    }
}
public class Priority {
    public static void main(String[] args) {
        //获取主线程的优先级
        int mainPriority=Thread.currentThread().getPriority();
        System.out.println("主线程优先级："+mainPriority);
        MyThread mt1=new MyThread("线程1");
        MyThread mt2=new MyThread("线程2");
        //mt1.setPriority(10);
        mt1.setPriority(Thread.MAX_PRIORITY);
        mt2.setPriority(Thread.MIN_PRIORITY);
        mt1.start();
        mt2.start();
        //System.out.println("线程1的优先级："+mt1.getPriority());
    }
}

线程同步

为了保证在存款和取款的时候，不允许其他线程对账户余额进行操作
需要将Bank对象进行锁定
使用关键字synchronized实现
synchronized关键字用在
1. 成员方法
2. 静态方法
3. 语句块
例子
1. public synchronized void saveAccount(){}
2. public static synchronized void saveAccount(){}
3. synchronized (obj){……}