目录
一:线程的优先级
Java提供一个线程调度器监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级,决定应该调度哪个线程执行
线程优先级用数字表示,范围1~10.
- Thread.MIN_PRIORITY=1
- Thread.MAX_PRIORITY=10
- Thread.NORM_PRIORITY=5
获得/改变优先级的方法:
- getPriority(),setPriority(int xxx)
代码示例
public class TestPriority {
public static void main(String[] args) {
//主线程
System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
//先设置优先级在打印
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);
t4.start();
}
}
class MyPriority implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());
}
}
结果截图:
优先级高的不一定先执行
二:守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 后台记录日志操作,监控内存,垃圾回收..
代码示例
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
// 创建一个线程,并将其设置为守护线程
Thread thread = new Thread(god);
thread.setDaemon(true);
thread.start();
// 创建一个新线程,并启动它
new Thread(you).start();
}
}
// 定义一个God类,实现Runnable接口
class God implements Runnable {
// 重写run方法
@Override
public void run() {
// 循环打印God
while (true) {
System.out.println("God");
}
}
}
class You implements Runnable {
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("alive");
}
System.out.println("goodbye world!");
}
}
三:线程同步
并发:多个线程操作同一个资源
处理多线程问题时,多个线程访问同一个对象,并且需要修改这个对象。需要进行线程同步。线程同步就是一种等待机制,多个需要同时访问此对象的线程进入这个对象线程池,形成队列,等待前面的线程使用完毕,下一个线程再使用。
形成条件:队列+锁
问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
不安全问题示例
1.买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station, "小红").start();
new Thread(station, "小张").start();
new Thread(station, "小王").start();
}
}
class BuyTicket implements Runnable {
private int ticketNum = 10;
boolean flag = true;//外部停止方式
@Override
public void run() {
//买票
while (flag) {
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if (ticketNum <= 0) {
flag = false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNum--);
}
}
2. 银行取钱
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "you");
Drawing girlFriend = new Drawing(account, 100, "girlFriend");
you.start();
girlFriend.start();
}
}
//账户
class Account {
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行,模拟取钱
class Drawing extends Thread {
Account account;
int drawingMoney;
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println("钱不够");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额
account.money = account.money - drawingMoney;
//手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为" + account.money);
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
Synchronized
同步块:synchronize(obj){}
Obj称为同步监视器
Obj可以是任何对象(推荐共享资源)
同步方法无需指定同步监视器(同步方法的监视器为this)
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访完毕,解锁同步监视器
- 第二个线程访问,发现同步见识器没有锁,锁定并访问
示例
private synchronized void buy() throws InterruptedException {
//判断是否有票
if (ticketNum <= 0) {
flag = false;
return;
}
//买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNum--);
}
锁变化的量
public void run() {
synchronized (account) {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println("钱不够");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额
account.money = account.money - drawingMoney;
//手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为" + account.money);
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而且导致两个或多个线程都在等待对方释放资源都停止执行的情形,某一个同步块同时拥有“两个以上对象”的锁是就可能会发生“死锁”问题。
代码示例
public class DeadLock {
public static void main(String[] args) {
Makeup g1=new Makeup(0,"小丽");
Makeup g2=new Makeup(1,"小红");
new Thread(g1).start();
new Thread(g2).start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
class Makeup extends Thread{
// 需要的资源只有一份
static Lipstick lipstick=new Lipstick();
static Mirror mirror=new Mirror();
int choice;
String girlName;
Makeup(int choice,String girlName){
this.choice=choice;
this.girlName=girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) { //获得口红锁
System.out.println(this.girlName + "获得口红锁");
Thread.sleep(1000);
synchronized (mirror) {
System.out.println(this.girlName + "获得镜子锁");
}
}
} else {
synchronized (mirror) { //获得口红锁
System.out.println(this.girlName + "获得镜子锁");
Thread.sleep(2000);
synchronized (lipstick) {
System.out.println(this.girlName + "获得口红锁");
}
}
}
}
}
运行结果:
解决方法:
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick) { //获得口红锁
System.out.println(this.girlName + "获得口红锁");
Thread.sleep(1000);
}
synchronized (mirror) {
System.out.println(this.girlName + "获得镜子锁");
}
} else {
synchronized (mirror) { //获得口红锁
System.out.println(this.girlName + "获得镜子锁");
Thread.sleep(2000);
}
synchronized (lipstick) {
System.out.println(this.girlName + "获得口红锁");
}
}
}
产生死锁的四个条件:
- 互斥条件:一个资源每次只能被一个进程使用
- 请求与保持条件: 一个进程因请求资源而阻塞时,对方获得的资源不放
- 不剥夺条件:进程已获得的资源,在未使用完之前不能强行剥夺
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
Lock
直接上代码:
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable {
int tickNums = 10;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock();
if (tickNums > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickNums--);
} else {
break;
}
} finally {
lock.unlock();
}
}
}
}
synchronized和Lock对比
- Lock是显示锁(手动开启关闭锁)synchronized是隐式锁,出了作用域自动释放。
- Lock只有代码块锁,synchronized有代码块和方法锁
- 使用Lock锁,JVM将花费较少的时间调度线程,性能更好 ,具有良好的可扩展性。
- 优先使用顺序: Lock>同步代码块(已经进入了方法体,分配了相应的资源)>同步方法(方法体之外)