正文
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.线程的状态?
1752
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
