Java多线程编程

文章目录

  • Java多线程编程
    • 线程概念
    • 线程常用方法
    • 线程创建
    • 线程优先级
    • 终止线程
    • 等待线程
    • 线程状态
    • 线程安全
    • synchronized
    • volatile
    • wait和notify方法
    • ThreadLocal的使用
    • 标准库线程安全类

Java多线程编程

线程概念

线程概念:

一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行
着多份代码

线程作用:

在多核CPU情况下,充分利用CPU资源;对于需要等待IO的任务,利用CPU资源

在创建,销毁,调度上相比进程更加轻量

进程和线程的区别:

进程是包含线程的,每个进程至少有一个线程存在,即主线程

进程和进程之间不共享内存空间,同一个进程的线程之间共享同一个内存空间

进程是系统分配资源的最小单位,线程是系统调度的最小单位

线程常用方法

Thread 类是 JVM 用来管理线程的一个类,换句话说,每个线程都有一个唯一的 Thread 对象与之关

构造方法:

方法 说明
Thread() 创建线程对象
Thread(Runnable target) 使用 Runnable 对象创建线程对象
Thread(String name) 创建线程对象,并命名
Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象,并命名
Thread(ThreadGroup group, Runnable target) 线程可以被用来分组管理,分好的组即为线程组,这 个目前我们了解即可

属性方法:

属性 获取方法
ID getId()
名称 getName()
状态 getState()
优先级 getPriority()
是否后台线程 isDaemon()
是否存活 isAlive()
是否被中断 isInterrupted()

注:优先级高的线程理论上来说更容易被调度到;JVM会在一个进程的所有非后台线程结束后,才会结束运行

启动线程:

t.start();//调用 start 方法, 才真的在操作系统的底层创建出一个线程

获取当前线程引用:

方法 说明
public static Thread currentThread(); 返回当前线程对象的引用

休眠当前线程:

方法 说明
public static void sleep(long millis) throws InterruptedException 休眠当前线程 millis 毫秒
public static void sleep(long millis, int nanos) throws InterruptedException 可以更高精度的休眠

线程创建

继承Thread类:

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        ThreadDemo t = new ThreadDemo();
        t.start();//创建线程+调用run()
        System.out.println("nihao");
    }
}

实现Runnable接口:

public class Thread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        Thread t = new Thread(new Thread2());
        t.start();//创建线程+调用run()
        System.out.println("nihao");
    }
}

匿名内部类Thread子类:

    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        t.start();
        System.out.println("nihao");
    }

匿名内部类Runnable子类:

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
        t.start();
        System.out.println("nihao");
    }

lambda表示式创建Runnable子类:

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello world");
        });
        t.start();
        System.out.println("nihao");
    }

线程优先级

Java采用的是抢占式调度方式,优先级越高的线程,优先使用CPU资源

我们希望CPU花费更多的时间去处理更重要的任务,而不太重要的任务,则可以先让出一部分资源。

线程的优先级一般分为以下三种:

  • MIN_PRIORITY 最低优先级
  • MAX_PRIORITY 最高优先级
  • NOM_PRIORITY 常规优先级
public static void main(String[] args) {
    Thread t = new Thread(() -> {
        System.out.println("线程开始运行!");
    });
    t.start();
    t.setPriority(Thread.MIN_PRIORITY);  //通过使用setPriority方法来设定优先级
}

终止线程

  1. 通过共享的标记来进行沟通
public class ThreadDemo {
    public static volatile boolean isQuit = false;//volatile保证内存可见性

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
                while (!isQuit) {//自动捕获‘final’属性的变量
                    System.out.println(Thread.currentThread().getName()
                            + ": hello worold!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()
                        + ": out of while");
        }, "李四");
        System.out.println(Thread.currentThread().getName()
                + ": start。");
        thread.start();
        Thread.sleep(10 * 1000);
        System.out.println(Thread.currentThread().getName()
                + ": down!");
        isQuit = true;
    }
}
  1. 调用 interrupt() 方法来通知

使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位

方法 说明
public void interrupt() 中断对象关联的线程,如果线程正在阻塞,则以异常方式通知, 否则设置标志位
public static boolean interrupted() 判断当前线程的中断标志位是否设置,调用后清除标志位
public boolean isInterrupted() 判断对象关联的线程的标志位是否设置,调用后不清除标志位
public class test1 {
    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            while(!Thread.interrupted()){
                System.out.println("working---");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //选择处理方式
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread interrupted");
        t.interrupt();
    }
}

thread 收到通知的方式有两种:

  1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起,则以 InterruptedException 异常的形式通
    知,清除中断标志;当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程
  2. 如果线程正在工作,则只是内部的一个中断标志被设置;Thread.interrupted() 判断当前线程的中断标志被设置,清除中断标志Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置,不清除中断标志

等待线程

有时需要等待一个线程完成它的工作后,才能进行自己的下一步工作。

方法 说明
public void join() 等待线程结束
public void join(long millis) 等待线程结束,最多等 millis 毫秒
public void join(long millis, int nanos) 同理,但可以更高精度
public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+" working...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "work finish");
        };
        Thread t1 = new Thread(r, "zhangsan");
        Thread t2 = new Thread(r, "lisi");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

线程状态

线程的状态是一个枚举类型 Thread.State

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}
NEW: 安排了工作, 还未开始行动
RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
BLOCKED: 这几个都表示排队等着其他事情,被锁给阻塞住了
WAITING: 这几个都表示排队等着其他事情,被wait()给阻塞住了
TIMED_WAITING: 这几个都表示排队等着其他事情,被sleep()给阻塞住了
TERMINATED: 工作完成了

状态转移图:

Java多线程编程_第1张图片

BLOCKED 表示等待获取锁

WAITING 和 TIMED_WAITING 表示等待其他线程发来通知

TIMED_WAITING 线程在等待唤醒,但设置了时限

WAITING 线程在无限等待唤醒

相关函数:

yield();//让出cpu,yield 不改变线程的状态, 但是会重新去排队
isAlive();//判断线程的存活状态

线程安全

多线程环境下代码运行的结果是符合我们预期的,即在单线程环境应该的结果,则说这个程序是线
程安全的。

修改共享数据:

多个线程针对 counter.count 变量进行修改,此时这个 counter.count 是一个多个线程都能访问到的 “共享数据”

原子性:

原子性表示一个资源在同一时间段下只有一个访问资源者进行操作

有时也把这个现象叫做同步互斥,表示操作是互相排斥的

一条 java 语句不一定是原子的,因为语句不一定包含的可能不只是一条指令

数据自增1底层操作步骤:

  1. 从内存把数据读到 CPU

  2. 进行数据更新

  3. 把数据写回到 CPU

synchronized

synchronized 是一个互斥锁, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到
同一个对象 synchronized 就会阻塞等待。

synchronized用的锁是存在Java对象头里的,synchronized的底层是使用操作系统的mutex lock实现的。

synchronized上锁是需要传入对象的,当对象不同时,获取到的是不同的锁,因此并不能保证自增操作的原子性。

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {//锁当前对象
        }
    }
}

synchronized关键字也可以作用于方法上,调用此方法时也会获取锁:

private static int value = 0;

private static synchronized void add(){
    value++;
}

如果是静态方法,就是使用的类锁,而如果是普通成员方法,就是使用的对象锁。通过灵活的使用synchronized就能很好地解决线程安全的问题。

synchronized 的工作过程:

  1. 获得互斥锁

  2. 从主内存拷贝变量的最新副本到工作的内存

  3. 执行代码

  4. 将更改后的共享变量的值刷新到主内存

  5. 释放互斥锁

synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息:

如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取
到锁, 并让计数器自增

解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

volatile

volatile 修饰的变量, 能够保证 “内存可见性”

Java多线程编程_第2张图片

直接访问工作内存(实际是 CPU 的寄存器或者 CPU 的缓存), 速度非常快, 但是可能出现数据不一致的情况。变量加上 volatile 关键字修饰, 强制读写内存,速度是慢了, 但是数据变的更准确了。

代码在写入 volatile 修饰的变量的时候:

  1. 改变线程工作内存中volatile变量副本的值
  2. 将改变后的副本的值从工作内存刷新到主内存

代码在读取 volatile 修饰的变量的时候:

  1. 从主内存中读取volatile变量的最新值到线程的工作内存中
  2. 从工作内存中读取volatile变量的副本

wait和notify方法

wait()notify()以及notifyAll()是需要配合synchronized来使用的(实际上锁就是依附于对象存在的,每个对象都应该有针对于锁的一些操作)。

对象的wait()方法会暂时使得此线程进入等待状态,同时会释放当前代码块持有的锁,这时其他线程可以获取到此对象的锁。

当其他线程调用对象的notify()方法后,会唤醒刚才变成等待状态的线程(必须是在持有锁(同步代码块内部)的情况下使用,否则会抛出异常)。

notifyAll其实和notify一样,也是用于唤醒,但是前者是唤醒所有调用wait()后处于等待的线程,而后者是看运气随机选择一个。

public static void main(String[] args) throws InterruptedException {
    Object o1 = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (o1){
            try {
                System.out.println("开始等待");
                o1.wait();     //进入等待状态并释放锁
                System.out.println("等待结束!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    Thread t2 = new Thread(() -> {
        synchronized (o1){
            System.out.println("开始唤醒!");
            o1.notify();     //唤醒处于等待状态的线程
          	for (int i = 0; i < 50; i++) {
               	System.out.println(i);   
            }
          	//唤醒后依然需要等待这里的锁释放之前等待的线程才能继续
        }
    });
    t1.start();
    Thread.sleep(1000);
    t2.start();
}

ThreadLocal的使用

Java多线程编程_第3张图片

每个线程都有一个自己的工作内存,可以使用ThreadLocal类,来创建工作内存中的变量,它将我们的变量值存储在内部(只能存储一个变量),不同的线程访问到ThreadLocal对象时,都只能获取到当前线程所属的变量。

public static void main(String[] args) throws InterruptedException {
    ThreadLocal<String> local = new ThreadLocal<>();  //注意这是一个泛型类,存储类型为我们要存放的变量类型
    Thread t1 = new Thread(() -> {
        local.set("lbwnb");   //将变量的值给予ThreadLocal
        System.out.println("变量值已设定!");
        System.out.println(local.get());   //尝试获取ThreadLocal中存放的变量
    });
    Thread t2 = new Thread(() -> {
        System.out.println(local.get());   //尝试获取ThreadLocal中存放的变量
    });
    t1.start();
    Thread.sleep(3000);    //间隔三秒
    t2.start();
}

线程中创建的子线程,无法获得父线程工作内存中的变量,使用InheritableThreadLocal来解决:

public static void main(String[] args) {
    ThreadLocal<String> local = new InheritableThreadLocal<>();
    Thread t = new Thread(() -> {
       local.set("lbwnb");
        new Thread(() -> {
            System.out.println(local.get());
        }).start();
    });
    t.start();
}

在InheritableThreadLocal存放的内容,会自动向子线程传递。

标准库线程安全类

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:

  1. ArrayList
  2. LinkedList
  3. HashMap
  4. TreeMap
  5. HashSet
  6. TreeSet
  7. StringBuilder

使用了一些锁机制来保证线程安全的类:

  1. Vector (不推荐使用)
  2. HashTable (不推荐使用)
  3. ConcurrentHashMap
  4. StringBuffer

不涉及 “修改”, 仍然是线程安全的:

  1. String
    (() -> {
    local.set(“lbwnb”);
    new Thread(() -> {
    System.out.println(local.get());
    }).start();
    });
    t.start();
    }

在InheritableThreadLocal存放的内容,会自动向子线程传递。

## 标准库线程安全类  

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:

1. ArrayList
2. LinkedList
3. HashMap
4. TreeMap
5. HashSet
6. TreeSet
7. StringBuilder  

使用了一些锁机制来保证线程安全的类:

1. Vector (不推荐使用)
2. HashTable (不推荐使用)
3. ConcurrentHashMap
4. StringBuffer  

不涉及 "修改", 仍然是线程安全的:

1. String  

你可能感兴趣的:(JavaSE,java,开发语言,jvm)