文章目录
引-相关概念
进程
- 进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程，有它自身的产生、存在和消亡的过程
线程
- 线程由进程创建，是进程的一个实体
- 一个进程可以拥有多个线程
单线程
- 同一个时刻，只允许执行一个线程
多线程
- 同一个时刻，可以执行多个线程，比如：一个QQ进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
并发
- 同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核CPU实现的多任务就是并发
并行
- 同一个时刻，多个任务同时执行，多核CPU可以实现并行
线程的基本使用
线程常用方法（一）
- setName 设置线程名称，使之与参数 name 相同
- getName 返回该线程的名称
- start 是该线程开始执行；java虚拟机底层调用该线程的 start0 方法
- run 调用线程的 run 方法
- setPriority 更改线程的优先级
- getPriority 获取线程的优先级
- sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
- interrupt 中断线程
注意事项和细节
- start 底层会创建新的线程，调用 run ，而 run 是一个简单的方法调用，不会启动新线程
- 线程优先级的范围
- interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
- sleep，线程的静态方法，使当前线程休眠
创建线程的两种方式
在 Java 中线程的使用有两种方法
- 继承 Thread 类，重写 run方法
- 继承 Runnable 接口，重写 run方法
继承 Thread 类
class Cat extends Thread {
@Override
public void run() { //重写run方法，写上自己的业务逻辑
System.out.println("miaomiao");
}
}
Cat cat = new Cat();
cat.start();//启动线程
说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
此时主线程和子线程是交替进行的。
为什么是start
如果直接调用run方法，则相当于调用了一个普通方法，没有真正的启动一个线程，需要把 run方法执行完毕才能够向下执行。
实现 Runnable接口
- Java 是单继承的，在某些情况下一个类可能已经继承了某个父类，此时再用继承 Thread类方法来创建线程显然不可能
- Java 设计者们提供了另外一个方法创建线程，就是通过实现 Runnable接口来创建线程
class Dog implements Runnable {
int count = 0;
@Override
public void run() {
System.out.println("hi... " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Dog dog = new Dog();
// 这里无法调用dog.start()方法，因为没有实现
//创建Thread对象，把dog对象（实现了Runnable接口），放入Thread
Thread thread = new Thread(dog);
thread.start();
两种方式的区别
- 从 Java 的设计来看，通过继承 Thread 或者实现 Runnable 接口来创建线程本质上没有区别，从 jdk 帮助文档我们可以看到 Thread 类本身就实现了 Runnable 接口 start() -> start0()
- 实现 Runnable 接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制
线程的退出
通知线程退出
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException {
T t = new T();
t.start();
Thread.sleep(1000);
t.setLoop(false);
}
}
class T extends Thread {
private boolean loop = true;
public void setLoop(boolean loop) {//通过set方法通知线程退出
this.loop = loop;
}
@Override
public void run() {
while(loop) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程运行中......");
}
}
}
常用方法（二）
- yield：线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功。
- join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程的所有任务。
用户线程和守护线程
- 用户线程：也叫工作线程，当线程的任务执行完成或通知方式结束
- 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
thread.setDameon(true);//设置守护线程
- 常见的守护线程：垃圾回收机制
线程生命周期
- JDK中用 Thread.State 枚举表示了线程的几种状态
线程同步机制
- 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，确保数据在任何时候，最多有一个线程访问，以保证数据的完整性。
- 也可以这样理解：线程同步，即当有一个线程在队内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
同步具体方法-Synchronized
- 同步代码块
synchronized(对象) { // 得到对象的锁，才能操作同步代码
// 需要被同步的代码
}
- synchronized 还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m (String name) {
// 需要被同步的代码
}
互斥锁
- 基本介绍
- Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
- 每个对象都对应于一个可称为”互斥锁“的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
- 关键字 synchronized 来与对象的互斥锁联系，当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问。
- 同步的局限性：导致程序的执行效率要降低。
- 同步方法（非静态的）的锁可以是 this，也可以是其他对象（要求是同一个对象）。
- 同步方法（静态的）的锁为当前类本身。
- 注意事项和细节
- 同步方法如果没有使用static修饰：默认锁对象为this
- 如果方法使 用static修饰，默认锁为对象：当前类.class
- 实现的的落地步骤：
- 需要先分析上锁的代码
- 选择同步代码块或同步方法（优先代码块，效率更高）
- 要求多个线程的锁对象为同一个即可
死锁
- 基本介绍
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程里是一定要避免死锁的发生。
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
A.start();
B.start();
}
}
//线程
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程A 得不到 o2 对象锁，就会Blocked
//3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程B 得不到 o1 对象锁，就会Blocked
if (flag) {
synchronized (o1) {//对象互斥锁, 下面就是同步代码
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}
释放锁
- 下面操作会释放锁
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的 wait()方法，当前线程暂停，并释放锁。
- 下面的操作不会释放锁
-
线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行，不会释放锁
-
线程执行同步代码块时，其他线程调用了该线程的 suspend()方法将该线程挂起，该线程不会释放锁
提示：应尽量避免使用suspend() 和 resume() 来控制线程，方法不再推荐使用
扫一扫
3038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
