本文详细介绍了多线程的基础概念、创建方式、数据共享与不共享的区别、常用的API、线程的停止与暂停方法、线程优先级与分类、线程状态、线程安全问题及解决方案、线程间的通信方式等内容。
多线程
进程 ： 进程就是正在执行的程序,是线程的集合
线程 ： 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
创建线程的三种方式 ：
- 继承Thread类,重写run方法
package wu.base.thread;
//创建线程方式一:继承Thread类,重写run方法
public class CreateThreadExtends extends Thread{
//run方法就是线程需要执行的任务或者执行的代码
@Override
public void run() {
for(int i = 0;i < 300;i++){
System.out.println("run,i:"+i);
}
}
}
package wu.base.thread;
public class ThreadDemo01 {
public static void main(String[] args){
CreateThreadExtends t1 = new CreateThreadExtends();
//启动线程不是调用run方法,而是调用start方法
//开启多线程后,代码不会从上往下执行
t1.start();
// t1.run();
for(int i = 0;i < 300;i++){
System.out.println("main,i:"+i);
}
}
}
- 实现Runnable接口
package wu.base.runnable;
//创建线程方式二:实现runnable接口
public class CreateThreadRunnable implements Runnable{
@Override
public void run() {
for(int i = 0;i < 3000;i++){
System.out.println("run,i:"+i);
}
}
}
package wu.base.runnable;
public class ThreadDemo02 {
public static void main(String[] args){
CreateThreadRunnable t2 = new CreateThreadRunnable();
Thread thread = new Thread(t2);
thread.start();
for(int i = 0;i < 3000;i++){
System.out.println("main,i:"+i);
}
}
}
- 匿名内部类
package wu.base.inner;
//创建线程方式三:匿名内部类
public class CreateThreadInner {
public static void main(String[] args){
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 3000;i++){
System.out.println("run,i:"+i);
}
}
});
t3.start();
for(int j = 0;j < 3000;j++){
System.out.println("main,j:"+j);
}
}
}
数据共享
- 数据不共享
package wu.base.data;
//数据不共享
public class MyThread extends Thread{
private int count = 5;
public MyThread(String name){
super();
this.setName(name );
}
@Override
public void run() {
super.run();
while(count > 0){
count--;
System.out.println("由 " + this.currentThread().getName() + " 计算 count=" + count);
}
}
}
package wu.base.data;
public class ThreadRun {
//三个不同的线程,不共享count
public static void main(String[] args){
MyThread A = new MyThread("A");
MyThread B = new MyThread("B");
MyThread C = new MyThread("C");
A.start();
B.start();
C.start();
}
}
- 数据共享
package wu.base.data;
//数据共享
public class MyThreadData extends Thread{
private int count = 5;
@Override
synchronized public void run() {
super.run();
count--;
System.out.println("由 " + this.currentThread().getName() + " 计算 count=" + count);
}
}
package wu.base.data;
public class DataRun {
public static void main(String[] args){
//五个不同的线程跑的都是Thread这一个线程
MyThreadData thread = new MyThreadData();
Thread A = new Thread(thread,"A");
Thread B = new Thread(thread,"B");
Thread C = new Thread(thread,"C");
Thread D = new Thread(thread,"D");
Thread E = new Thread(thread,"E");
A.start();
B.start();
C.start();
D.start();
E.start();
}
}
常用API
-
currentThread()
获取当前正在执行该代码片的线程
-
isAlive()
判断当前线程是否处于活跃状态，活动状态是指线程已经启动且尚未停止
-
sleep()
作用是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）this.currenThread返回的线程
-
getId()
获取线程的唯一ID
-
getName()
获取线程的Ｎame
-
setName()
设置线程Name
-
join()
先让另外一个线程执行完毕后,再执行自己
-
yieId()
放弃当前的CPU资源,将他让给其他的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片
例题 : 现有t1、t2、t3三个线程，怎样保证t2在t1执行完成后执行，t3在t2执行完后执行
t1 -> t2 -> t3
package wu.base.api;
//join()方法:先让另外一个线程执行完毕后,再执行自己
//现有t1、t2、t3三个线程，怎样保证t2在t1执行完成后执行，t3在t2执行完后执行
public class ThreadJoin {
public static void main(String[] args){
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 10;i++){
System.out.println("t1 : "+ i);
}
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 50;i++){
System.out.println("t2 : "+ i);
}
try{
t1.join();
}catch(Exception e){
e.printStackTrace();
}
}
});
t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0;i < 100;i++){
System.out.println("t3 : "+ i);
}
try{
t2.join();
}catch(Exception e){
e.printStackTrace();
}
}
});
t3.start();
}
}
停止线程
interrupt()：并不会停止线程,该方法仅仅只是在线程中打了一个停止的标记,并不是真正停止线程
判断一个线程是否是停止的状态：
1、this.interrupted():测试当前线程是否已经中断,当前线程是指运行this.currentThread()方法的线程
第一次thread.interrupted，调用thread.interrupted()显示false，但是thread并没有停止，所以证明是测试当前线程main的中断标志
第二次Thread.currentThread().interrupt()，调用Thread.interrupted()第一次显示true，第二次显示false。所以证明测试当前线程main的中断标志是正确的，但是第二次显示false,是由于interrupted方法可以清除中断标志，也就是说，连续两次调用interrupted方法，第二次将会对中断标志进行清除
public class MyThread extends Thread {
@Override
public void run() {
super.run();
for(int i = 0;i < 5000;i++){
System.out.println("i = " + i);
}
}
}
public class TestThread {
public static void main(String[] args){
try{
MyThread thread = new MyThread();
thread.start()；
thread.interrupt();
System.out.println("是否停止线程:" + thread.interrupted());
System.out.println("是否停止线程:" + thread.interrupted());
//Thread.currentThread().interrupt();
//System.out.println("是否停止线程:" + Thread.currentThread().getName() +" " + Thread.interrupted());
//System.out.println("是否停止线程:" + Thread.currentThread().getName() +" " + Thread.interrupted());
}catch(Exception e) {
System.out.println("main catch");
e.printStackTrace();
}
}
}
2、this.isInterrupted()：测试线程是否已经中断
isInterrupted()并未清除线程的状态标志,而且测试的是Thread对象
thread.interrupt();
System.out.println("是否停止线程:" + thread.isInterrupted());
System.out.println("是否停止线程:" + thread.isInterrupted());
//Thread.currentThread().interrupt();
System.out.println("是否停止线程:" + Thread.currentThread().isInterrupted());
System.out.println("是否停止线程:" + Thread.currentThread().isInterrupted());
判断线程是否停止的状态后，可以根据得到的状态来停止线程：
通过判断停止的状态，如果是停止的状态，就抛出异常
@Override
public void run() {
super.run();
try{
for(int i = 0;i < 5000;i++){
if(this.isInterrupted()){
System.out.println("已经是停止状态了,要退出了~");
throw new InterruptedException();
}
System.out.println("i = " + i);
}
System.out.println("for后面的语句,如果不是捕获异常,而是break的话,那将继续执行");
}catch(InterruptedException e){
System.out.println("在run中捕获到异常:InterruptedException");
e.printStackTrace();
}
}
public class StopTest {
public static void main(String[] args) throws Exception{
try{
StopThread thread = new StopThread();
thread.start();
Thread.sleep(20);
thread.interrupt();
}catch(Exception e){
e.printStackTrace();
}
}
}
通过判断停止的状态,如果是停止的状态,就return
public class ReturnThread extends Thread{
@Override
public void run(){
while(true){
if(this.isInterrupted()){
System.out.println("停止了~");
return;
}
}
}
}
public class ReturnTest {
public static void main(String[] args) throws Exception{
try{
ReturnThread thread = new ReturnThread();
thread.start();
Thread.sleep(200);
thread.interrupt();
}catch(Exception e){
e.printStackTrace();
}
}
}
线程在sleep中停止会产生异常
public class SleepStopThread extends Thread {
@Override
public void run() {
super.run();
try{
System.out.println("run begin:");
for(int i = 0;i < 1000;i++){
System.out.println("i = " + i);
}
Thread.sleep(2000);
System.out.println("run end:");
}
catch (InterruptedException e){
System.out.println("在sleep中停止,进入中断异常" + this.isInterrupted());
e.printStackTrace();
}
}
}
public class SleepStopTest {
public static void main(String[] args){
try{
SleepStopThread thread = new SleepStopThread();
thread.start();
Thread.sleep(200);
thread.interrupt();
}catch(Exception e){
System.out.println("main catch~");
e.printStackTrace();
}
System.out.println("main end:");
}
}
stop暴力停止线程
但是这个方法不建议使用,这个方法可能在未来的JDK中被废弃
在线程里边调用stop()方法会抛出java.lang.ThreadDeath异常
stop()强制停止会让一些清理性的工作无法完成,还有就是对锁定的对象进行了"解锁",导致数据无法得到同步处理,出现数据不一致的问题
暂停线程
suspend():暂停线程
resume():恢复线程
但是这两个方法会造成公共的同步对象的独占,使得其他线程无法访问公共同步对象,而且这两个方法也容易导致数据的不同步
线程的优先级
设置线程优先级的方法是setPriority(),线程的优先级分为1~10这10个等级,如果小于1或者大于10,会抛出IllegalArgumentException异常
线程优先级的特性：
- 继承性：A线程启动B线程，那么B线程的优先级与A的优先级一样
- 规则性：CPU尽量将资源让给优先级比较高的线程
- 随机性：优先级比较高的线程不一定每一次都先执行完
线程分类
守护线程 ：当进程不存在或主线程停止，守护线程也会被停止
如JVM的垃圾回收，内存管理都是守护线程，还有就是在做数据库应用的时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监听连接个数、超时时间、状态等。
gc线程主要回收主线程里面的,有专门回收子线程垃圾的线程
非守护线程（用户线程）：用户自己创建的线程,如果主线程销毁,不会影响到用户线程
线程的几种状态：
- 新建 new Thread()
- 就绪 start() 等待CPU调度
- 运行 CPU开始执行run()方法
- 休眠 在运行时调用sleep()或wait()方法,进入就绪状态
- 停止 run()方法代码执行完毕或者调用stop()方法
线程安全
当多个线程共享同一个全局变量,进行写操作的时候,可能会受到其他线程的干扰,导致数据有问题,这种现象称为线程安全问题
-
原子性 : 提供了互斥访问,同一时刻只能有一个线程来对他进行访问
-
可见性 : 一个线程对主内存的修改可以及时的被其他线程观察到
-
有序性 : 一个线程观察其他线程的指令执行顺序,有误指令重排序的存在,该观察结果一般杂乱无章
synchronized
MyObject.java
public class MyObject {
synchronized public void methodA(){
try{
System.out.println("begin methodA : threadName = " + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end methodA : endTime = " + System.currentTimeMillis());
}catch(Exception e){
e.printStackTrace();
}
}
synchronized public void methodB(){
try{
System.out.println("begin methodB : threadName = " + Thread.currentThread().getName()
+ " beginTime = " + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end methodB");
}catch(Exception e){
e.printStackTrace();
}
}
}
ThreadA.java
public class ThreadA extends Thread {
private MyObject object;
public ThreadA(MyObject object){
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodA();
}
}
ThreadB.java
public class ThreadB extends Thread {
private MyObject object;
public ThreadB(MyObject object){
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodB();
}
}
TestRun.java
public class TestRun {
public static void main(String[] args){
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}
结论：
- A线程先持有object对象的锁，B线程可以异步调用object对象中的非synchronized类型的方法
- A线程先持有object对象的锁，B线程如果在这个时候要调用object对象中的synchronized类型的方法则需要等待，也就是同步
可重入锁：自己可以再次获得自己的内部锁。当一个线程得到一个对象锁后，此时这个对象锁还没有释放，当其想再次获取这个对象的锁的时候，还是可以获得的。如果不是可重入锁，这么做会造成死锁
可重入锁也支持在父子类继承的环境中，子类可以通过可重入锁调用父类的同步方法
1、synchronized是可重入锁
2、发生异常，锁自动释放
3、同步不具有继承性
synchronized同步代码块
synchronized(this){}
1、synchronized(this)中的代码的就同步执行，不在代码块中的代码就异步执行
2、synchronized(this)是锁定当前对象的
3、当一个线程访问object的一个synchronized(this)同步代码快时，其他线程对同一个object中所有其他synchronized(this)同步代码块的访问将被阻塞，说明synchronized使用的“对象监视器”是同一个
synchronized(非 this 对象 x){}
把其他的对象作为“对象监视器”来实现同步
锁非this对象具有一定的优点：如果一个类中有很多个synchronized方法，这是虽然能实现同步，但会受到阻塞，所以影响运行效率；
但是如果使用同步代码块锁非this对象，则synchronized(非 this x)代码块中的程序与同步方法是异步的，不与其他锁this的同步方法竞争this锁，则可以提高运行效率
细节：
1、当多个线程同时执行synchronized(x){}同步代码块时呈同步效果
2、当其他线程执行x对象中synchronized同步方法时呈现同步效果
3、当其他线程执行x对象方法里面的synchronized(this)代码块时也会呈现同步效果
静态同步synchronized方法和synchronized(class)代码块
将关键字用到static静态方法上时，是对当前的.java文件对应的Class类上锁，而将关键字加到非static上是对对象上锁，Class锁可以对类的所有的实例起到作用。synchronized(class)跟synchronized static 是一样的，都是对class上锁
volatile
强制从公共堆栈中取得变量的值，而不是从私有数据栈中取得变量的值，使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字不支持原子性
synchronized和volatile的比较：
- 关键字volatile是线程同步的轻量级实现，所以volatile的性能比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法以及代码块。但是现在synchronized的效率也在提升
- 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞
- volatile能保证数据的可见性，但不能保证原子性；synchronized可以保证原子性，也可以间接保证可见性，因为他会将私有内存和公共内存中的数据做同步
- volatile解决的是变量在多线程之间的可见性；synchronized解决的是多个线程之间访问资源的同步性
线程间的通信
wait()：作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或者被中断为止。**在执行wait()方法前，线程必须先获得该对象的对象级别锁，即只能在同步方法或同步代码块中调用wait()方法。在执行完wait()方法后，当前线程释放锁。**如果调用wait()方法时没有获取到适当的锁，则会抛出IllegalMonitorStateException，是RuntimeException的子类
notify()：也要在同步代码块或同步方法中调用，**即在调用前,线程必须获得该对象的对象级别锁。**该线程用来通知其他等待该对象的对象锁的线程，如果有多个线程在等待，则由线程规划器随机挑选出其中一个等待的线程，对其发起通知，并使他获得该对象的对象锁。
**说明：在执行notify后，当前线程不会马上释放该对象锁，等待状态的线程也不能马上获取该对象锁，要等到执行notify方法的线程将程序执行完，也就是推出synchronized代码块后，当前线程才会释放锁，等待状态的线程才可以获得该对象锁。**当第一个获得了该对象锁的wait线程运行完毕后，它会释放该对象锁，此时如果没有再次使用notify语句，则即便该对象已经空闲，其他线程等待的线程由于没有得到notify，还会继续阻塞在wait状态，直到该对象发出一个notify或notifyAll。
wait(long)：等待某一时间内是否有线程对锁进行唤醒，如果超过时间后没有，则自动唤醒
例：生产者——消费者
生产者和消费者之间不直接通信，而是通过阻塞队列进行通信，所以生产者产生完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列中取数据
操作的数据类
public class ValueObject {
public static String value = "";
}
消费者类
public class Consumer {
private String lock;
public Consumer(String lock){
super();
this.lock = lock;
}
public void getValue(){
try{
synchronized (lock){
if(ValueObject.value.equals("")){
lock.wait();
}
System.out.println("get 的值是 " + ValueObject.value);
ValueObject.value = "";
lock.notify();
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
生产者类
public class Producer {
private String lock;
public Producer(String lock){
super();
this.lock = lock;
}
public void setValue(){
try{
synchronized (lock){
if(!ValueObject.value.equals("")){
lock.wait();
}
String value = System.currentTimeMillis() +" _" + System.nanoTime();
System.out.println("set 的值是 " + value);
ValueObject.value = value;
lock.notify();
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
消费者线程类
public class ThreadConsumer extends Thread {
private Consumer consumer;
public ThreadConsumer(Consumer consumer){
super();
this.consumer = consumer;
}
@Override
public void run() {
super.run();
while(true){
consumer.getValue();
}
}
}
生产者线程类
public class ThreadProducer extends Thread {
private Producer producer;
public ThreadProducer(Producer producer){
super();
this.producer = producer;
}
@Override
public void run() {
super.run();
while(true){
producer.setValue();
}
}
}
测试类
public class RunTest {
public static void main(String[] args){
String lock = new String("");
Producer producer = new Producer(lock);
Consumer consumer = new Consumer(lock);
ThreadProducer threadProducer = new ThreadProducer(producer);
ThreadConsumer threadConsumer = new ThreadConsumer(consumer);
threadProducer.start();
threadConsumer.start();
}
}
通过管道进行线程间通信
PipeInputStream 和 PipeOutputStream：字节流
PipeReader 和 PipeWriter：字符流
connect()的作用使两个Stream之间产生通信连接 out.connect(input) OR input.connect(output)
ThreadLocal
ThreadLocal类解决的是每个线程绑定自己的值，变量在不同线程间的隔离性，也就是不同的线程拥有自己的值。
get()方法获取值，set()方法设置值
默认第一次get到的是null，解决这个方法可以让一个类继承ThreadLocal，重写initiaValue()方法，返回一个自己的值
InheritableThreadLocal
这个类可以在子线程中取得父线程继承下来的值，但是如果子线程在取得的同时，主线程将InheritableThreadLocal中的值进行了修改，那么子线程取到的值还是旧值
Lock接口
ReentrantLock
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//获取锁
lock.lock();
//等同于wait()
condition.await();
//等同于notify()
condition.signal();
//等同于notifyAll()
condition.signalAll();
//释放锁
lock.unlock();
使用Condition实现等待/通知,可以创建多个Condition对象实例，唤醒特定的线程，例下：
MyService.java
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public 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 signalA(){
try{
lock.lock();
System.out.println("begin signalA : " + System.currentTimeMillis()
+ " threadName = " + Thread.currentThread().getName());
conditionA.signalAll();
}finally{
lock.unlock();
}
}
public void signalB(){
try{
lock.lock();
System.out.println("begin signalB : " + System.currentTimeMillis()
+ " threadName = " + Thread.currentThread().getName());
conditionB.signalAll();
}finally{
lock.unlock();
}
}
}
ThreadA.java
public class ThreadA extends Thread {
private MyService service;
public ThreadA(MyService service){
super();
this.service = service;
}
@Override
public void run() {
super.run();
service.awaitA();
}
}
ThreadB.java
public class ThreadB extends Thread {
private MyService service;
public ThreadB(MyService service){
super();
this.service = service;
}
@Override
public void run() {
super.run();
service.awaitB();
}
}
Run.java
public class Run {
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.signalA();
}
}
公平锁：表示线程获取锁的顺序是按照加锁的顺序来分配的
非公平锁：随机获得锁，可能导致一些线程一直拿不到锁，就一直无法执行
Lock lock = new ReentrantLock(boolean 是否是公平锁);
ReentrantReadWriteLock
ReentrantLock类具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务，虽然保证了安全，但是效率比较低。
读写锁表示有两个锁，一个是读操作相关的锁，也称为共享锁；一个是写操作相关的锁，也称为排他锁。 也就是多个读锁之间不互斥，读锁与写锁、写锁与写锁之间是互斥的。可以有多个线程同时进行读操作，但是同一时刻只能有一个线程进行写操作。
扫一扫
3104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
