线程
相当于轻量级进程，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存、文件句柄和其它每个进程应有的状态。
构建一个线程
//创建一个新线程 参数为实现了 Runnable 接口的类实例
Thread t = new Thread(run);
//启动线程
t.start();线程终止
- run方法完成自动退出
- 一个没有捕获的异常终止了run方法而意外死亡
- stop方法 已弃用
- interrupt方法，重设中断状态,发出中断请求,如果该线程被sleep调用阻塞会抛出异常InterruptedException
线程状态
- New 创建
- Runnable 可运行
- Blocked 被阻塞
- Waiting 等待
- Timed waiting 计时等待
- Terminated 被终止
抢占式调度
一个进程处于Runnable状态，也可能没有运行，取决于操作系统给时间提供的运行时间
线程让步
暂停当前正在执行的线程对象,让其他线程先执行,
实际中无法保证yield()达到让步目的,
因为让步的线程还有可能被线程调度程序再次选中。
守护线程
t.setDaemon(true);注意:
不要直接调用run方法，这样不能启动新线程,当设计多线程应用程序的时候，一定不要依赖于线程的优先级,因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。
demo
public class MyRunnable implements Runnable {
public String name = null;
@Override
public void run() {
for(int i =0;i<100;i++){
// try {
// Thread.sleep(3);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(i + name);
}
}
public static void main(String[] args) {
MyRunnable run = new MyRunnable();
run.name = "aaaa";
MyRunnable run2 = new MyRunnable();
run2.name = "bbbbb";
Thread t = new Thread(run);
Thread t2 = new Thread(run2);
/**
* 设置优先级 1~10
* Thread.MAX_PRIORITY
* Thread.NORM_PRIORIT
* Thread.MIN_PRIORITY
*/
t.setPriority(8);
/**
* 设置一个线程异常处理器
*/
t.setUncaughtExceptionHandler(new MyErrorHandler());
/**
* 启动线程
*/
t.start();
/**
* 等调用join的线程执行完成再执行下面接着的线程
*/
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
/**
* 设为守护线程 要在线程启动前调用
*/
t2.setDaemon(true);
t2.start();
//用以判断当前线程是否为中断状态
Thread.currentThread().isInterrupted();
/**
* 线程让步
* 暂停当前正在执行的线程对象,让其他线程先执行,
* 实际中无法保证yield()达到让步目的,
* 因为让步的线程还有可能被线程调度程序再次选中。
*/
Thread.yield();
}
}
//异常处理器
public class MyErrorHandler implements UncaughtExceptionHandler {
/**
* 这里可以做任何针对异常的处理,比如记录日志等等
*/
public void uncaughtException(Thread a, Throwable e) {
System.out.println("This is:" + a.getName() + ",Message:"
+ e.getMessage());
e.printStackTrace();
}
}同步
/**
当多个线程操作同一个对象时，容易出现数据异常状态，
具体原因是当一个线程获取了所需要的参数，准备赋值时等待，
另外一个线程也获取了所需要的参数进行了赋值
这时第一个赋值被唤醒，其值会覆盖第二个线程的值
*/
public class HeroProperties {
public int mana = 1000;
public void useSkill(){
mana -= 10;
System.out.println("剩余蓝:" + mana);
}
}
public class SyncRunnable implements Runnable{
public SyncRunnable(HeroProperties hero){
this.hero = hero;
}
public HeroProperties hero;
@Override
public void run() {
hero.useSkill();
}
public static void main(String[] args) {
HeroProperties hero = new HeroProperties();
for(int i=0;i<1000;i++){
SyncRunnable r = new SyncRunnable(hero);
Thread t = new Thread(r);
t.start();
}
}
}
/*
打印的结果：出现重复数据
剩余蓝:980
剩余蓝:960
剩余蓝:970
剩余蓝:980
剩余蓝:940
剩余蓝:950
剩余蓝:930
剩余蓝:920
...
剩余蓝:-100
剩余蓝:-110
*/锁对象-ReentrantLock
使用锁对象 使赋值的代码块变为同步
/**
创建锁
Lock lock = new ReentrantLock();
锁
lock.lock();
解锁
lock.unLock();
*/
public class HeroProperties {
public int mana = 1000;
public Lock lock = new ReentrantLock();
public void useSkill(){
//锁
lock.lock();
mana -= 10;
System.out.println("剩余蓝:" + mana);
//解锁
lock.unlock();
}
}
/*
打印结果没有出现重复值
剩余蓝:990
剩余蓝:980
剩余蓝:970
剩余蓝:960
剩余蓝:950
剩余蓝:940
剩余蓝:930
剩余蓝:920
...
剩余蓝:-100
剩余蓝:-110
*/条件锁-Condition
此时值出现负数是异常的,mana要大于0才能使用skill，要添加一个条件使mana小于0时进行等待mana的恢复，恢复之后再继续使用skill,此时就要使用条件锁，不符合条件是线程进入等待，又不会造成死锁。
/**
Lock lock = new ReentrantLock();
Condition cd = lock.newCondition();
//该条件不满足时调用await，线程进入等待
cd.await();
//其他线程执行完之后 激活所有等待的线程
cd.signalAll();
//激活随机一条线程
cd.signal();
*/
/**
Lock lock = new ReentrantLock();
Condition cd = lock.newCondition();
//该条件不满足时调用await，线程进入等待
cd.await();
//其他线程执行完之后 激活所有等待的线程
cd.signalAll();
//激活随机一条线程
cd.signal();
*/
public class HeroProperties {
public int mana = 100;
public Lock lock = new ReentrantLock();
public Condition cd = lock.newCondition();
public void useSkill() throws InterruptedException{
lock.lock();
//自然恢复的蓝量
mana+=1;
System.out.println(Thread.currentThread() +"尝试使用技能---------"+ "蓝量:"+mana);
if(mana<10) {
System.out.println(Thread.currentThread() +"ZZZZZZZZZZZZ"+"线程睡眠");
cd.await();
}
//有可能是被唤醒的线程
if(mana<10) {
//尝试唤醒的时候不一定能直接运行，也有可能被其他线程执行了操作导致该线程操作失败
System.out.println(Thread.currentThread() +"随机唤醒的线程不符合条件");
}else{
//蓝条刚好只剩下一次的时候吃药
boolean isUseItem = (mana==10);
System.out.println(Thread.currentThread() + "蓝量:" + mana);
mana -= 10;
System.out.println(Thread.currentThread() + "使用技能后剩余蓝:" + mana);
if(isUseItem) {
mana += 30;
System.out.println("吃药恢复30");
}
if(mana>=10) {
//唤醒所有线程
//cd.signalAll();
//随机唤醒一个线程
cd.signal();
}
}
lock.unlock();
}
}synchronized
可以在方法名添加 synchronized 关键字实现同步
/**
* wait() 线程进入等待
* notify() 随机唤醒一个线程
* notifyAll() 唤醒所有线程
*/
public synchronized void useSkill(){
//do something
//wait();
}同步阻塞，synchronized一个对象组成一个代码块，该代码块就能实现同步
Object lock = new Object()
public void useSkill(){
synchronized(obj){
//do something
}
}