Java 多线程 初阶
并发与并行
- 并发：多个线程在一段时间内交替运行，某一时刻只有一个线程在运行
- 并行：多个线程在某一时刻同时运行
进程和线程
- 进程：是拥有系统资源的基本单位，有独立的地址空间，切换开销较大
- 线程：是系统调度的基本单位，线程本身不拥有系统资源，同属一个进程的多个线程共享进程中的资源，没有独立的地址空间，只是进程的不同执行路径，切换开销较小
多线程的优缺点
- 优点：多线程可以使响应速度更快，切换开销比进程小，可以随时停止任务，也可以设置优先级
- 缺点：需要协调和管理，防止死锁
创建启动线程
-
通过继承Thread类创建线程类
- 定义Thread的子类，重写run方法，run方法的方法体代表线程要执行的任务
- 创建该继承类实例对象，该对象就是线程对象，调用start方法启动线程
/* * Thread子类 */ public class NewThread extends Thread{ @override public void run(){ System.out.println("new Thread"); Thread.currentThread(); } } /* * 调用 */ public void main(String[] args){ NewThread newThread = new newThread(): newThread.start(); }注：Java默认有一个主线程，它的方法体是main函数；currentThread()静态方法返回当前执行的线程对象；start()实例方法代表线程进入就绪状态，等到处理机调度的时候会自动调用线程的run()方法，假如在代码中显式调用newThread.start()，则调用线程是main而不是newThread，线程任务是newThread的run()方法内容，因此永远不要显式调用run()方法，这根本就不是多线程
-
实现Runnable接口创建线程类
- 定义Runnable接口的实现类，并重写run()方法，这个run()方法同样是线程的任务方法体
- 创建该实现类实例对象，将次实例作为Thread的target创建Thread对象，Thread对象才是真正的线程对象
/* * Runnable实现类 */ public class NewRunnable implements Runnable{ @Override public void run(){ System.out.println("new Runnable"); Thread.currentThread(); } } /* * 调用 */ public void main(String[] args){ NewRunnable newRunnable = new NewRunnable(): new Thread(newRunnable).start(); } -
使用继承Thread方法创建多线程与使用实现Runnable接口方法创建多线程的区别
- 继承方法中新类已继承Thread类，由于Java单继承，所以不能再继承其他类，访问当前线程可使用this
- 实现方法中新类可以继承其他类，可以实现多个线程共享一个target对象，访问当前线程必须使用Thread.currentThread()
线程生命周期
- 新建状态：当使用new线程时，新线程创建完后即进入新建状态
- 就绪状态：线程对象调用start()方法后，线程进入就绪状态。当系统调度要运行该线程时，该线程就可以进入运行状态
- 运行状态：线程被系统调度运行，线程进入运行状态，执行run()方法
- 阻塞状态：线程由于某些原因被阻塞，暂停运行让出CPU，CPU通过系统调度运行其他线程，结束阻塞状态的线程不能直接进入运行状态，只能进入就绪状态等待运行。线程进入阻塞状态的原因可能是调用sleep()方法主动让出处理器、调用了阻塞式的IO方法未返回、同步资源被占用、等待某个nitofy等原因
- 结束状态：线程完成run()方法正常结束或者线程抛出未捕获的异常，又或者调用stop()方法结束，线程进入结束状态
线程控制
- join()方法
join()是线程类的实例方法，表示调用线程进入阻塞状态，等待被调用线程完成执行，再继续执行调用线程。无参的join()等价于有参的join(0)，join(int mills)中参数代表调用线程阻塞的毫秒数，过了这个时间不再阻塞
- sleep()方法
static void sleep(long mills)是线程类的静态方法，代表当前运行线程进入阻塞状态，参数是阻塞的毫秒数，过了这个时间不再阻塞，sleep()方法声明抛出InterruptedException异常
- yield()方法
static void yield()是线程类的静态方法，代表当前运行线程进入就绪状态。进入就绪状态只是代表当前线程让出处理机等待系统重新调度，完全有可能出现当前线程重新被处理机运行的情况。系统调度一般会运行与当前线程同优先级或更高优先级的线程，yield()方法没有声明抛出异常
线程同步
- 同步关键字synchronized
假如有以下业务逻辑：
- 用户输入账户密码，系统判断用户的账户密码是否匹配
- 用户输入提款进入
- 系统判断账户余额是否大于取款金额
- 如果余额大于等于取款金额则取款成功，否则取款失败
假如有两个用户登录同一账户取款，这就相当于有两个线程去执行这一段程序，如果不加同步处理，那么极有可能出现的情况是：两个用户取款的金额都小于余额，但是总取款额小于余额，导致取款完后发现余额为负值
因此就需要线程同步，在访问共享资源时在某一时间段只能有一个线程访问，同步需要同步监视器，即任意时刻只能有一个线程获取同步监视器对象。synchronized关键字修饰代码块时synchronized(obj){}的obj就是同步监视器， 修饰静态方法时，该类就是同步监视器，修饰非静态方法时，类对象就是同步监视器。同步代码结束后，线程自动释放对同步监视器的锁定。
注：所谓同步监视器实际上就是锁。
- 当调用synchronized修饰的静态方法时，类就会被上锁，任何访问该类静态方法的线程将被阻塞
- 当调用synchronized修饰的实例方法时，类实例对象就会被上锁，任何访问该对象的任何synchronized修饰的实例方法将被阻塞
- 但是线程A对类对象上了锁，线程B访问类synchronized修饰的静态方法不会阻塞，因为A加的是对象锁，B将要加的是类锁，互不干扰
- synchronized修饰代码块的情况，锁是加在同步监视器这个对象上的
- synchronized关键字修饰的方法被继承后子类该方法不拥有synchronized关键字
public class DrawThread extends Thread{
//账户
private Account account;
//其他属性...
//构造方法
public DrawThread(String account,double drawAmount){
}
//run()方法
@Override
public void run(){
synchronized(account){
//业务逻辑
}
}
}
在以下情况，线程会释放同步监视器的锁定：
- 同步代码执行结束
- 同步代码遇到break、return终止关键字
- 同步代码出现未处理异常
- 执行了同步监视器的wait()方法
在以下情况，线程不会释放同步监视器的锁定:
- 程序调用Thread.sleep()或Thread.yield()方法
- 同步锁(Lock)
synchronized的锁只能被隐式的获取和释放，不能被很好的控制，这就出现了Lock。Lock是一个接口，常用如下方法
void lock()//加锁
Boolean tryLock()//尝试获取锁，获取成功返回true，否则返回false
void lockInterruptibly()//尝试获取锁，获取失败则中断线程的等待，抛出异常
void unlock()//释放锁
Condition newCondition()//线程协作类对象
ReentrantLock(可重入锁)实现了Lock接口，可重入就是线程对自己已加锁的target再次加锁，通过维护计数器来追踪加锁次数，当计数器值为0才释放target，这个锁是直接加在代码块的，而不是类或者实例对象
public class Account{
//定义锁对象属性
private final ReentrantLock lock = new ReentrantLock();
//其他属性..
//构造方法..
//线程安全的取钱方法
public void draw(drawAmount){
//加锁
try{
lock.lock();
//业务逻辑
}finally{
//解锁
lock.unlock();
}
}
}
一些锁的概念
- 可重入锁：程对自己已加锁的target再次加锁，通过维护计数器来追踪加锁次数，当计数器值为0才释放target。比如线程A访问synchronized方法1给对象上了锁，线程A再访问方法synchronized方法2再次给对象上锁。synchronized和ReentrantLock都是可重入锁
- 可中断锁：线程想要共享资源，发现共享资源已被加锁，自己进入等待状态，可以通过中断结束线程的等待状态的锁就是可中断锁，Lock是可中断锁，synchronized不是
- 公平锁：按照等待时间长短来控制访问的锁。synchronized是非公平锁，ReentrantLock默认是非公平的，但是可以设置公平锁
- 死锁：两个或者多个线程互相持有对方所需的资源，导致这些线程都处于等待状态无法执行。四个必要条件是：互斥条件、不剥夺条件、请求和保持条件、循环等待条件
线程协作
- synchronized修饰的关键字与线程协作
同步代码块可以进行协作。通过使用同步监视器对象的wait()、notify()、notifyAll()方法，进行synchronized修饰的关键字的线程协作。这些方法是Object类的实例方法。
wait()：导致当前线程等待，并且释放对同步监视器的锁定，直到其他线程调用该的同步监视器的notify()方法或notifyAll()方法唤醒线程。可以带一个毫秒参数
notify()：唤醒在此同步监视器上等待的单个线程，唤醒只是进入就绪状态
notifyAll()：唤醒在此同步监视器上等待的所有线程
假如有业务是存钱取钱存钱取钱。。这样协作运行的，简单代码示例如下
/*
* 账户类
*/
public class Account{
//属性..
//取钱
public synchronized void draw(double drawAmount){
if(!haveMoney){//未存钱
wait();
}else{
//取钱业务..
haveMoney = false;
notifyAll();
}
}
//存钱
public synchronized void deposit(double drawAmount){
if(haveMoney) {//已存钱
wait();
}else{
//存钱业务..
haveMoney = true;
notifyAll();
}
}
}
- Lock对象与线程协作
Lock对象加锁加在代码块上，无法使用wait()、notify()、notifyAll()方法，使用Condition类的await()、signal()、signalAll()方法来替代之前三个方法的功能。
/*
* 账户类
*/
public class Account{
private final Lock lock = new ReentrantLock();
private final Condition cond = lock.newCondition();
//其他属性..
//取钱
public void draw(double drawAmount){
if(!haveMoney){//未存钱
cond.await();
}else{
//取钱业务..
haveMoney = false;
cond.signalAll();
}
}
//存钱
public void deposit(double drawAmount){
if(haveMoney) {//已存钱
cond.await();
}else{
//存钱业务..
haveMoney = true;
cond.signalAll();
}
}
}
关于线程池
新建一个线程的开销是比较高的，所以线程池在系统启动的时候就创建了大量空闲的线程，程序将一个Runnable对象传给线程池，线程池就会启动一条线程来执行Runnable对象的run()方法，run()方法结束后，线程不会立刻死亡，而是返回线程池中编程空闲状态继续等待调度。线程池还可以有效控制系统中并发线程的数量，因为线程高并发可能导致系统性能剧烈下降
关于ThreadLocal<T>类
ThreadLocal<T>为每一个线程保留一个变量值的副本，线程间的副本相互独立不会冲突，主要有以下方法
T get()
void set(T value)
void remove();
//示例
ThreadLocal<String> name = new ThreadLocal<String>();
name.set("David");
String userName = name.get();
name.remove();
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
