Java:认识多线程



概述

什么是线程???

进程的概念:进程是指可执行程序并存放在计算机存储器的一个指令序列,他是一个动态执行的过程。

进程的概念和特征_C语言中文网 (biancheng.net)

线程是比进程还要小的运行单位,一个进程含多个线程

Thread类和Runnable接口介绍

线程创建

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

Thread类

  • Thread是一个线程类,位于java.lang包下
Thread类
  • Thread类的常用方法
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类的方法

Runnable接口
/**
 * 用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();
    }
}

线程的生命周期

线程状态

  1. 新建状态(New)
  2. 可运行状态(Runnable)
  3. 正在运行(Running)
  4. 阻塞(Blocked)
  5. 终止(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());
    }
}

线程同步

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

线程间通信

  • wait()方法:中断方法的执行,使线程等待
  • notify()方法:唤醒处于等待的某一个线程,使其结束等待
  • notifyAll()方法:唤醒所有处于等待的线程,使其结束等待
© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片