1.线程安全问题-共享资源能使用问题
2.同步代码块
synchronize( /*锁对象 */){
}
/*
特征:
1. synchronized 小括号里面的对象是锁对象,并且要求如果是多线程的情况下,锁对象必须是同一个对象。
2. synchronized 大括号中的代码块就是需要进行同步的代码,或者说是加锁的代码,大括号里面的内容,有且只允许一个线程进入。
3. 同步代码块越短越好,在保证安全的情况下,提高性能
问题:
1. 目前锁对象感觉很随意,存在一定的隐患
2. 代码层级关系很复杂,看着有点麻烦
*/
package com.qfedu.b_synchronized;
/*
* 共享资源冲突问题
*/
/**
* 自定义售票线程类
*
* @author Anonymous
*
*/
class SingleThread implements Runnable {
// 共享资源
private static int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
ticket -= 1;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄!");
break;
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
Thread thread1 = new Thread(new SingleThread(), "淘票票");
Thread thread2 = new Thread(new SingleThread(), "猫眼");
Thread thread3 = new Thread(new SingleThread(), "美图");
thread1.start();
thread2.start();
thread3.start();
}
}
3.同步方法
synchronized 作为关键字来修饰方法,修饰的方法就是对应的同步方
有且只允许一个线程进入,到底是谁来完成的加锁操作?
1. 静态成员方法
锁对象,是当前类对应的字节码文件.class 类名.class
2. 非静态成员方法
锁对象就是当前类对象 this
选择同步方法是否使用static修饰问题
1. 如果非static修饰,要保证执行的线程对象有且只有一个,因为锁对象就是当前线程对
象
2. 如果是static修饰,锁对象具有唯一性,多个线程使用的锁是同一个锁。
package com.Demo2;
/*
* 共享资源冲突问题
*/
/**
* 自定义售票线程类
*
* @author Anonymous
*
*/
class SingleThread implements Runnable {
// 共享资源
private static int ticket = 100;
@Override
public void run() {
while (true) {
/**
* 调用一个同步方法
*/
sellTicket();
if (0==ticket){
break;
}
}
}
/**
* 完成一个同步方法,该方法是一个非静态成员方法,所对象就是this.当前类对象
*/
public synchronized void sellTicket(){
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
ticket -= 1;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄!");
}
}
}
public class Demo1 {
public static void main(String[] args) {
Thread thread1 = new Thread(new SingleThread(), "淘票票");
Thread thread2 = new Thread(new SingleThread(), "猫眼");
Thread thread3 = new Thread(new SingleThread(), "美图");
thread1.start();
thread2.start();
thread3.start();
}
}
4.Lock锁
Java提供了一个对于线程安全问题,加锁操作相对于同步代码块和同步方法更加广泛的一种操作方式。
1. 对象化操作。
创建Lock构造方法
Lock lock = new ReentrantLock();
2. 方法化操作。
开锁:
unlock();
加锁:
lock();
package com.qfedu.b_synchronized;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
* 共享资源冲突问题
*/
/**
* 自定义售票线程类
*
* @author Anonymous
*
*/
class SingleThread5 implements Runnable {
// 共享资源
private static int ticket = 100;
// 定义一个成员变量
static Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
// lock对象加锁
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "张票");
ticket -= 1;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + "售罄!");
break;
}
// 解除锁
lock.unlock();
}
}
}
public class Demo5 {
public static void main(String[] args) {
Thread thread1 = new Thread(new SingleThread5(), "淘票票");
Thread thread2 = new Thread(new SingleThread5(), "猫眼");
Thread thread3 = new Thread(new SingleThread5(), "美图");
thread1.start();
thread2.start();
thread3.start();
}
}
5.三种加锁方式的总结
1. 一锁一线程,一锁多线程问题。
使用对应的锁操作对应的线程,考虑静态和非静态问题。
同步方法和Lock锁使用。
静态是一锁多目标,非静态是一锁一目标
2. 涉及到同步问题时,要考虑好锁对象的选择问题
同步代码块,同步方法,Lock对象。
6.守护线程
守护线程,也称之为后台线程,如果当前主线程GG思密达,守护线程也就GG思密达。
守护线程一般用于:
1. 自动下载
2. 操作日志
3. 操作监控
方法是通过线程对象
setDeamon(boolean flag);
true为守护线程
false缺省属性,正常线程
7.线程状态
7.1线程六大状态
| 状态 | 导致状态的发生条件 |
| :---------------------- | :----------------------------------------------------------- |
| NEW(新建) | 线程刚刚被创建,没有启动,没有调用start方法 |
| RUNNABLE(可运行) | 线程已经可以在JVM中运行,但是是否运行不确定,看当前线程是否拥有CPU执行权 |
| BLOCKED(锁阻塞) | 当前线程进入一个同步代码需要获取对应的锁对象,但是发现当前锁对象被其他线程持有,当前线程会进入一个BLOCKED。如果占用锁对象的线程打开锁对象,当前线程持有对应锁对象,进入Runnable状态 |
| WAITING(无限等待) | 通过一个wait方法线程进入一个无限等待状态,这里需要另外一个线程进行唤醒操作。进入无限等待状态的线程是无法自己回到Runnable状态,需要其他线程通过notify或者notifyAll方法进行唤醒操作 |
| TIMED_WAITING(计时等待) | 当前线程的确是等待状态,但是会在一定时间之后自动回到Runnable状态,例如 Thread.sleep() 或者是Object类内的wait(int ms); |
| TERMINATED(被终止) | 因为Run方法运行结束正常退出线程,或者说在运行的过程中因为出现异常导致当前线程GG思密达 |
7.2TIMED_WAITING(计时等待)
Thread.sleep(int ms);
在对应线程代码块中,当前线程休眠指定的时间。
Object类内 wait(int ms);
让当前线程进入一个计时等待状态
1. 规定的时间及时完毕,线程回到可运行状态
2. 在等待时间内,通过其他线程被notify或者notifyAll唤醒
Sleep方法
1. 调用之后休眠指定时间
2. sleep方法必须执行在run方法内,才可以休眠线程
3. sleep不会打卡当前线程占用的锁对象。
7.3 BLOCKED(锁阻塞)
线程中有锁存在,线程需要进入带有锁操作的同步代码,如果锁对象被别人持有,只能在锁外等待
锁阻塞状态的线程是否能够抢到锁对象有很多因素
1. 优先级问题,非决定因素
2. CPU执行概率问题。
后期高并发一定会存在多线程操作锁对象问题,秒杀,抢购...
队列方式来处理