一下仅做个人学习总结用。
一、多线程概述
1.实现多线程的方法
1).继承Thread类
package com.zqj.thread.extendthread;
public class Run {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.start();
System.out.println("运行结束");
}
}
class Mythread extends Thread{
public void run(){
System.out.println("extend Thread");
}
}
运行结果:
Tips:
- 线程被调用的时间是随机的;
- 使用多线程技术时,代码的运行结果与代码执行顺序或调用顺序是无关的;
- 在上面代码中也可以使用“mythread.run();”来启动线程。与使用start方法的区别是:使用start方法启动时通知“线程规划器”此线程已经准备好,让系统安排一个时间来调用run()启动线程;而直接调用run()是由main主线程来调用run(),必须等run()里面的代码执行完才能执行后面的代码,是同步执行;
- 当启动多个线程时,start()的顺序不代表线程的启动的顺序;
2).实现Runnable接口
package com.zqj.thread.extendthread;
public class Run {
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
System.out.println("运行结束");
}
}
class MyRunnable implements Runnable{
public void run(){
System.out.println("extend Thread");
}
}
运行结果:
Tips:
- Thread类也实现了Runnanle接口
- 构造函数Thread(Runnable target)不光可以传入Runnable接口的对象,还可以传入一个Thread对象。这样可以将一个Thread对象的run()方法教给其他线程调用
3.线程中的一些方法
- currentThread():返回代码段正在被哪个线程调用的信息
- isAlive():判断当前线程是否处于活动状态
- sleep():休眠当前正在执行的线程
- getId():获取线程的唯一标识
- yield():放弃当前CPU资源,但时间不确定,可能刚放弃又马上获得CPU时间片
二、对象及变量的并发访问
1.实例变量的非线程安全问题
package com.zqj.thread.extendthread;
public class TestRun {
public static void main(String[] args) {
HasSelfPrivateNum nunRef = new HasSelfPrivateNum();
ThreadA threadA = new ThreadA(nunRef);
threadA.start();
ThreadB threadB = new ThreadB(nunRef);
threadB.start();
}
}
class HasSelfPrivateNum{
private int num = 0;
public void addI(String username){
try {
if(username.equals("a")){
num = 100;
System.out.println("a set over");
Thread.sleep(2000);
}else {
num = 200;
System.out.println("b set over");
}
System.out.println(username + " num=" +num);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
class ThreadA extends Thread{
private HasSelfPrivateNum numRef;
public ThreadA(HasSelfPrivateNum numRef){
this.numRef = numRef;
}
public void run(){
numRef.addI("a");
}
}
class ThreadB extends Thread{
private HasSelfPrivateNum numRef;
public ThreadB(HasSelfPrivateNum numRef){
this.numRef = numRef;
}
public void run(){
numRef.addI("b");
}
}
执行结果:
num作为方法中的公有变量,两个线程同时访问时发生数据不一致。A线程未执行完,B线程进入了,改变了num的值,导致a num =200;如果在public void addI(String username)方法前加入关键字synchronized,可使两个线程同步。
Tips:
- synchronized关键字取得的锁都是对象锁
- 哪个线程先执行带synchronized关键字的方法,哪个线程就持有该方法所属对象的锁,其他线程只能等待;前提是多个线程访问的是同一个对象
- 如果访问多个对象,JVM会创建多个锁
- synchronized锁可重入,即同一个线程在得到这个对象锁时,可以再次获得该对象锁;
- 线程出现异常,锁会自动释放
- 同步不能继承,子类方法仍然需要添加synchronized关键字
2.synchronized同步语句块
synchronized同步语句块可以对某一段代码使用,仅使这一段代码具有同步性;让其他线程可以执行方法中其他不需要同步的地方,提高代码执行效率
synchronized(this)锁定当前对象,synchronized也可以锁定其他任意对象
synchronized加在static方法上时是给Class类加锁,加到非static方法是给对象加锁;这两种锁是不同的,Class锁可以对类的所有实例起作用。synchronized(class)代码块的作用和synchronized static方法一样
3.volatile关键字
volatile关键字的作用是使变量在多个线程可见,强制从公共堆中取得变量的值,而不是从线程私有数据栈中取得变量的值。
package com.zqj.thread.volatiles;
public class TestRun {
public static void main(String[] args) {
try {
RunThread thread = new RunThread();
thread.start();
Thread.sleep(1000);
thread.setRunning(false);
System.out.println("已经被赋值为false");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class RunThread extends Thread{
private boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean running) {
this.isRunning = running;
}
public void run(){
System.out.println("进入run");
while (isRunning == true){
}
System.out.println("线程被停止了");
}
}
运行结果:
在上面的代码中,变量private boolean isRunning = true;存在于公共堆栈和线程的私有堆栈中。而线程从私有堆栈中取得的isRunning的值一直是true。thread.setRunning(false);虽然被执行但更新的却是共有堆栈中的isRunning值变为false。所以使用volatile关键字定义isRunning,使得当线程访问isRunning变量时强制从公共堆栈取值。
修改为volatile private boolean isRunning = true;后运行结果:
4.volatile和synchronized的比较
Tips:
- vloatile只用于修饰变量;而synchronized可用于修饰方法及代码块
- 多线程访问volatile不会发生阻塞,而synchronized会阻塞
- volatile只能保证数据的可见性,不能保证原子性;而synchronized可以保证原子性,可以间接保证数据可见性,因为synchronized会将私有内存和公共内存中的数据同步
- 关键字volatile解决的是变量在多个线程之间的可见性;而synchronized解决的是多个线程之间访问资源的同步性
三、线程间的通信
1、等待/通知机制
wait()方法释放当前线程持有的锁,立即释放
notify()方通知那些等待对象锁的其他线程,线程规划器随机挑选一个wait状态的线程唤醒。notify()方法所在线程代码执行完后才释放锁
notifyAll()方法唤醒所有wait中的线程,但这些线程也只会随机执行一个
2.线程状态
运行态、等待态、阻塞态;线程状态之间的切换示意图如下:
3.类ThreadLocal的使用
变量的值共享可以使用public static变量的形式,所有的线程都使用同一个public static变量。如果想要实现每一个线程都有自己共享变量,可以使用ThreadLocal解决。类ThreadLocal解决每个线程绑定自己的值。
package com.zqj.thread.threadloc;
public class RunThreadLocal {
public static void main(String[] args) {
ThreadA threadA = new ThreadA();
ThreadB threadB = new ThreadB();
threadA.start();
threadB.start();
}
}
class Tools{
public static ThreadLocal t1 = new ThreadLocal();
}
class ThreadA extends Thread{
@Override
public void run() {
try {
for(int i = 0;i < 10;i++){
Tools.t1.set("ThreadA"+(i+1));
System.out.println("ThreadA get Value"+Tools.t1.get());
Thread.sleep(200);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
class ThreadB extends Thread{
@Override
public void run() {
try {
for(int i = 0;i < 10;i++){
Tools.t1.set("ThreadB"+(i+1));
System.out.println("ThreadB get Value"+Tools.t1.get());
Thread.sleep(200);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
上面代码中虽然两个线程都向t1对象中set()数据,但每个线程还是能取到自己的数据。
四、Lock的使用
1.使用RenntrantLock类
使用方法:定义一个锁Lock lock = new RenntrantLock(); 使用lock.lock();和 lock.unlock();为包围的代码块上锁;
2.使用Condition实现等待/通知
使用ReentrantLock结合Condition类可以实现“选择性通知”;使用Condition类可以唤醒部分指定线程
package com.zqj.thread.reentrantlock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionReen {
public static void main(String[] args) throws InterruptedException{
MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.setName("A");
a.start();
ThreadB b = new ThreadB(service);
b.setName("B");
b.start();
Thread.sleep(3000);
service.signallAll_A();
}
}
class MyService{
private Lock lock = new ReentrantLock();
public Condition conditionA = lock.newCondition();
public Condition conditionB = lock.newCondition();
public void awaitA(){
try {
lock.lock();
System.out.println("begin awaitA 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
conditionA.await();
System.out.println("end awaitA时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void awaitB(){
try {
lock.lock();
System.out.println("begin awaitB 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
conditionB.await();
System.out.println("end awaitB时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void signallAll_A(){
try {
lock.lock();
System.out.println("signallAll_A 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
conditionA.signalAll();
}finally {
lock.unlock();
}
}
public void signallAll_B(){
try {
lock.lock();
System.out.println("signallAll_B 时间为"+System.currentTimeMillis()+"ThreadName="+Thread.currentThread().getName());
conditionA.signalAll();
}finally {
lock.unlock();
}
}
}
class ThreadA extends Thread{
private MyService service;
public ThreadA(MyService service) {
this.service = service;
}
@Override
public void run() {
service.awaitA();
}
}
class ThreadB extends Thread{
private MyService service;
public ThreadB(MyService service) {
this.service = service;
}
@Override
public void run() {
service.awaitB();
}
}
运行结果:
运行程序后,只有线程A被唤醒了。
3.一些方法
- int getHoldCount():查询当前线程保持此锁定的个数
- int getQueueLength:返回正在等待获取此锁定的线程估计数;比如有5个线程,一个线程首先执行await()方法,在调用getQueueLength()方法后返回值是4,说明有4个线程在等待lock释放
- int getWaitQueueLength(Condition condition):作用是返回等待 与此线程相关的给定条件Condition的估计数;比如有5个线程,每个线程都执行了同一个Condition对象的await()方法,则调用getWaitQueueLength(Condition condition)方法时返回值是5
- boolean hasQueueThread():作用是查询指定的线程是否正等待获取此锁定。用法如lock.hasQueueThread(threadA)
- boolean hasWaiters(Condition condition):作用是查询是否有线程正在等待与此锁定有关的condition;用法如lock.hasWaiters(conditionA)
- boolean isFair():作用是判断是不是公平锁;默认情况下,ReentrantLock类使用的非公平锁。
- boolean isHeldByCurrentThread():作用是查询当前线程是否持有此锁定
- boolean isLocked():作用是查询此锁定是否由任意线程保持
- lockInterruptibly():如果当前线程未被中断,则获取锁定,如果已经被中断则出现异常
- boolean tryLock():仅在调用时锁定未被另一个线程保持的情况下,才获取此锁定
- boolean tryLock(long timeout,TimeUnit unit):如果锁定在给定等待时间内没有被另一个线程保持,且当前线程未被中断,则获取该锁定
4.使用ReentrantReadWriteLock类
一个是读操作相关的锁readLock(),也称为共享锁;另一个是写操作的相关的锁writeLock(),也叫排他锁。多个读锁之间不互斥,读锁和写锁互斥,写锁和写锁之间互斥。在没有线程进入写入操作时,进行读取的多个线程都可以获取读锁,而进入写入操作的线程只有在获取写锁后才能进入写入操作。即多个线程可以同时进行读取操作,但是同一时刻只允许一个线程进入写入操作