网站特效 素材,wordpress文章更新,对市场营销的认识,莱芜东风街吧文章目录 Java多线程编程线程概念线程常用方法线程创建线程优先级终止线程等待线程线程状态线程安全synchronizedvolatilewait和notify方法ThreadLocal的使用标准库线程安全类 Java多线程编程
线程概念
线程概念#xff1a;
一个线程就是一个 “执行流”. 每个线程之间都可… 文章目录 Java多线程编程线程概念线程常用方法线程创建线程优先级终止线程等待线程线程状态线程安全synchronizedvolatilewait和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)线程可以被用来分组管理分好的组即为线程组这 个目前我们了解即可
属性方法
属性获取方法IDgetId()名称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 {Overridepublic 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{Overridepublic 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(){Overridepublic 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() {Overridepublic 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方法来设定优先级
}终止线程
通过共享的标记来进行沟通
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;}
}调用 interrupt() 方法来通知
使用 Thread.interrupted() 或者 Thread.currentThread().isInterrupted() 代替自定义标志位
方法说明public void interrupt()中断对象关联的线程如果线程正在阻塞则以异常方式通知 否则设置标志位public static boolean interrupted()判断当前线程的中断标志位是否设置调用后清除标志位public boolean isInterrupted()判断对象关联的线程的标志位是否设置调用后不清除标志位
public class test1 {static class MyRunnable implements Runnable {Overridepublic 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 收到通知的方式有两种
如果线程因为调用 wait/join/sleep 等方法而阻塞挂起则以 InterruptedException 异常的形式通 知清除中断标志当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程如果线程正在工作则只是内部的一个中断标志被设置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: 工作完成了状态转移图 BLOCKED 表示等待获取锁 WAITING 和 TIMED_WAITING 表示等待其他线程发来通知 TIMED_WAITING 线程在等待唤醒但设置了时限 WAITING 线程在无限等待唤醒 相关函数
yield();//让出cpuyield 不改变线程的状态, 但是会重新去排队
isAlive();//判断线程的存活状态线程安全
多线程环境下代码运行的结果是符合我们预期的即在单线程环境应该的结果则说这个程序是线 程安全的。
修改共享数据
多个线程针对 counter.count 变量进行修改此时这个 counter.count 是一个多个线程都能访问到的 “共享数据”
原子性
原子性表示一个资源在同一时间段下只有一个访问资源者进行操作
有时也把这个现象叫做同步互斥表示操作是互相排斥的
一条 java 语句不一定是原子的因为语句不一定包含的可能不只是一条指令
数据自增1底层操作步骤 从内存把数据读到 CPU 进行数据更新 把数据写回到 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 的工作过程: 获得互斥锁 从主内存拷贝变量的最新副本到工作的内存 执行代码 将更改后的共享变量的值刷新到主内存 释放互斥锁
synchronized 同步块对同一条线程来说是可重入的不会出现自己把自己锁死的问题
在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息
如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取 到锁, 并让计数器自增
解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)
volatile
volatile 修饰的变量, 能够保证 “内存可见性” 直接访问工作内存(实际是 CPU 的寄存器或者 CPU 的缓存), 速度非常快, 但是可能出现数据不一致的情况。变量加上 volatile 关键字修饰, 强制读写内存速度是慢了, 但是数据变的更准确了。
代码在写入 volatile 修饰的变量的时候
改变线程工作内存中volatile变量副本的值将改变后的副本的值从工作内存刷新到主内存
代码在读取 volatile 修饰的变量的时候
从主内存中读取volatile变量的最新值到线程的工作内存中从工作内存中读取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的使用 每个线程都有一个自己的工作内存可以使用ThreadLocal类来创建工作内存中的变量它将我们的变量值存储在内部只能存储一个变量不同的线程访问到ThreadLocal对象时都只能获取到当前线程所属的变量。
public static void main(String[] args) throws InterruptedException {ThreadLocalString local new ThreadLocal(); //注意这是一个泛型类存储类型为我们要存放的变量类型Thread t1 new Thread(() - {local.set(lbwnb); //将变量的值给予ThreadLocalSystem.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) {ThreadLocalString local new InheritableThreadLocal();Thread t new Thread(() - {local.set(lbwnb);new Thread(() - {System.out.println(local.get());}).start();});t.start();
}在InheritableThreadLocal存放的内容会自动向子线程传递。
标准库线程安全类
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施:
ArrayListLinkedListHashMapTreeMapHashSetTreeSetStringBuilder
使用了一些锁机制来保证线程安全的类
Vector (不推荐使用)HashTable (不推荐使用)ConcurrentHashMapStringBuffer
不涉及 “修改”, 仍然是线程安全的
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
