正文
1. Thread类中常用的一些方法:
2. 解决线程安全问题
3. 线程死锁问题
4. 线程通信
5. 线程池
1.Thread类中常用的一些方法
start()
:启动线程,使线程开始执行其任务。run()
:线程执行的任务代码,通常在子类中重写该方法来定义线程的具体工作。sleep(long milliseconds)
:使线程休眠指定的毫秒数。join()
:等待该线程终止。isAlive()
:检查线程是否还存活(即是否正在执行或已经终止)。interrupt()
:中断线程。isInterrupted()
:检查线程是否被中断。setName(String name)
:设置线程的名称。getName()
:获取线程的名称。yield()
:暂停当前正在执行的线程对象,并执行其他线程。setPriority(int priority)
:设置线程的优先级。getPriority()
:获取线程的优先级。currentThread()
:静态方法,获取当前执行的线程对象。
- start():案例
public class MyThread extends Thread {
public void run() {
System.out.println("Thread is running");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}
在这个案例中,我们创建了一个继承自Thread类的自定义线程类MyThread,重写了run方法来定义线程的具体任务。在main方法中,创建了一个MyThread对象并调用start方法来启动线程执行任务。
- sleep(long milliseconds):案例
System.out.println("Start");
Thread.sleep(2000); // 休眠2秒
System.out.println("End");
在这个例子中,主线程打印"Start",然后调用sleep(2000)
方法使主线程休眠2秒,接着打印"End"。这个方法可以用来实现线程暂停或延迟执行。
- join():案例
Thread thread = new Thread(() -> {
System.out.println("Thread is running");
});
thread.start();
thread.join(); // 等待thread线程执行完毕
System.out.println("Main thread finished");
在这个例子中,主线程创建一个新线程并启动它,然后通过join()
方法等待该线程执行完毕后再继续执行主线程。这样可以控制线程的执行顺序。
- isAlive():案例
Thread thread = new Thread(() -> {
System.out.println("Thread is running");
});
thread.start();
System.out.println("Is thread alive? " + thread.isAlive());
在这个例子中,主线程创建一个新线程并启动它,然后通过isAlive()
方法检查该线程是否还存活(执行中或已终止),并将结果打印出来。
- interrupt():案例
Thread thread = new Thread(() -> {
while (!Thread.interrupted()) {
System.out.println("Thread is running");
}
});
thread.start();
thread.interrupt(); // 中断线程
在这个例子中,我们在子线程中使用while循环来持续执行任务,通过interrupt()
方法中断线程的执行。在循环中,可以通过Thread.interrupted()
方法来检查线程是否被中断。
yield(),
setPriority(int priority),
getPriority(),
currentThread()案例
public class ThreadPriorityExample extends Thread {
public void run() {
System.out.println("Thread " + this.getName() + " is running with priority: " + this.getPriority());
Thread.yield();
System.out.println("Thread " + this.getName() + " is running again after yielding.");
}
public static void main(String[] args) {
ThreadPriorityExample thread1 = new ThreadPriorityExample();
thread1.setPriority(Thread.MIN_PRIORITY);
ThreadPriorityExample thread2 = new ThreadPriorityExample();
thread2.setPriority(Thread.MAX_PRIORITY);
thread1.start();
thread2.start();
System.out.println("Current executing thread: " + Thread.currentThread().getName());
}
}
在这个案例中,我们创建了两个不同优先级的ThreadPriorityExample线程对象,分别启动它们,并使用getPriority()
方法获取和设置线程优先级。在run
方法中,我们打印线程的名字和优先级,然后调用yield()
方法暂停当前线程的执行,让其他线程有机会执行。在main
方法中,我们启动这两个线程并打印当前执行的线程名字。
当你运行这段代码时,你会看到类似以下输出:
Thread Thread-0 is running with priority: 1
Thread Thread-1 is running with priority: 10
Current executing thread: main
Thread Thread-0 is running again after yielding.
Thread Thread-1 is running again after yielding.
2. 解决线程安全问题
4.1 什么情况下会出现线程安全问题
当多个线程操作同一个资源时,则出现线程安全问题。
4.2 java如何解决线程安全问题
synchronized
synchronized关键字:使用synchronized关键字可以确保同一时刻只有一个线程可以访问某个代码块或方法,从而避免多个线程同时访问造成的数据竞争问题。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
在这个示例中,increment()
和getCount()
方法都用synchronized
关键字修饰,确保在同一时刻只有一个线程能够访问这两个方法,避免了多线程操作count
变量时可能出现的数据竞争问题。
原子类
使用原子类:Java提供了一些原子类,如AtomicInteger、AtomicLong等,这些类提供了一些原子操作,可以保证在多线程环境下对变量的操作是原子的,从而避免线程安全问题。
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet();
}
public int getCount() {
return count.get();
}
}
在这个示例中,count
变量被定义为AtomicInteger
类型,increment()
方法和getCount()
方法通过原子操作incrementAndGet()
和get()
保证了对count
变量的操作是原子的,从而避免了线程安全问题。
Lock
使用Lock接口:Java提供了Lock接口及其实现类ReentrantLock,可以实现更灵活的同步控制。使用Lock接口可以更精确地控制线程的访问顺序。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}
在这个示例中,我们创建了一个Counter
类,其中包含一个ReentrantLock
类型的lock对象。increment()
方法和getCount()
方法通过lock对象的lock()
方法获取锁,执行代码块后通过unlock()
方法释放锁。这样可以确保在同一时刻只有一个线程可以执行increment()
或getCount()
方法,避免了多线程访问共享资源时可能出现的问题。
syn和lock区别
syn可以使用代码块和方法。自动加锁和释放锁。不会出现死锁问题。
lock它只能使用在代码块中。需要手动加锁和释放锁。如果不释放锁,死锁问题。灵活。它的释放锁必须放在finally.
3.死锁
线程A拥有锁资源a,希望获取锁资源b,线程B拥有锁资源b,希望获取锁资源a。 两个线程互相拥有对方希望获取的锁资源。可能会出现程序堵塞。从而造成死锁。
解决方法
1. 不要使用锁嵌套。
2. 设置超时时间。--Lock类中tryLock.
3. 使用安全java.util.concurrent下的类。
4.线程通信
在 Java 中,wait()
和 notify()
方法是用于实现线程间通信的重要方法,通常与 synchronized
关键字结合使用。
wait()
: 当线程调用wait()
方法时,它会释放当前持有的对象锁,并进入等待(wait)状态,直到其他线程调用相同对象上的notify()
或notifyAll()
方法来唤醒它。线程在等待期间不消耗 CPU 资源。
synchronized (obj) {
// some code
obj.wait(); // 线程进入等待状态
// 继续执行
}
notify()
: 当线程调用notify()
方法时,它会唤醒在此对象上调用wait()
方法而进入等待状态的一个线程。如果有多个线程在等待,哪个线程被唤醒是不确定的。
synchronized (obj) {
// some code
obj.notify(); // 唤醒一个等待的线程
// 继续执行
}
需要注意的是,wait()
和 notify()
方法必须在同步块(synchronized)中调用,因为它们需要获取对象锁来确保线程安全。
另外,还有 notifyAll()
方法,它会唤醒在此对象上调用 wait()
方法而进入等待状态的所有线程。在多线程场景中,使用 notifyAll()
可以避免可能出现的假死情况。
5.线程状态
- 新建(New):线程被创建但尚未开始执行时的状态。
- 中止(Terminated):线程执行完毕或者被提前终止后的状态。
- 就绪(Ready):线程已经创建,但是还没有运行,等待系统分配资源执行。
- 运行(Running):线程正在执行任务时的状态。
- 阻塞(Blocked):线程被挂起,等待某个条件满足后再继续执行。
- 等待(Waiting):线程正在等待某个特定事件发生。
- 休眠(Sleeping):线程主动放弃执行权限,等待定时器唤醒。
- 结束(Dead):线程执行完毕或者被终止后的状态。
- 定时状态(Timed Waiting):线程在等待特定时间内的状态,等待时间结束后会自动转为就绪状态。
- 等...
6.课时小结
1.Thread类中常用方法。
2. syn和lock的区别?
3.什么是死锁和如何避免死锁。
4. notify和notifyAll的区别。
5. wait和sleep方法。
注
wait
和sleep
都是用于暂停程序执行一段时间的方法。它们的主要区别在于使用上的场景和用途。
wait
方法通常用于线程间的通信,它会使当前线程进入等待状态,直到被其他线程唤醒。在Java中,Object
类提供了wait()
方法用于线程间的同步和通信。synchronized (obj) { try { obj.wait(); // 当前线程进入等待状态 } catch (InterruptedException e) { // 处理InterruptedException异常 } }
sleep
方法通常用于让当前线程暂停执行一段时间,不会释放对象锁。在Java中,Thread类提供了sleep()
方法用于线程的暂停。try { Thread.sleep(1000); // 线程暂停1秒 } catch (InterruptedException e) { // 处理InterruptedException异常 }
总的来说,
wait
主要用于线程间的通信和同步,而sleep
主要用于线程的时间控制和暂停。
6.线程的状态?