一、基本概念
程序 ：一段静态的代码，为了完成某个特定的任务
进程 ：程序的一个执行过程或者或理解为正在执行的一个程序
- 程序是静态的，进程是动态的
线程： 进程的细化就是线程，是程序内部的一条执行路径
- 同一个进程中的多个线程共同分享相同的内存单元/内存地址空间
Java程序中默认有main线程、垃圾回收线程和异常处理线程
二、线程的创建与使用
使用java.lang.Thread类进行线程创建
Thread类中常用的方法
| 方法名 | 作用 |
|---|---|
| void start() | 启动线程，并执行对象的run()方法 |
| run() | 线程在被调度时执行的操作 |
| String getName() | 返回线程的名称 |
| void setName(String name) | 设置该线程名称 |
| static Thread currentThread() | 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable类的实现 |
| yied() | 释放当前CPU的执行权 |
| join() | 在线程a中调用线程b的join()方法，此时线程a进入阻塞状态，直到线程b完全执行以后。线程a才结束阻塞状态 |
方式一：继承于Thread类
- 创建一个继承于Thread类的子类
- 重写Thread的run方法
- 创建Thread类子类的对象
- 通过此对象调用start()
// 1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2.重写Thread的run方法
public void run() {
System.out.println("线程创建");
}
}
public class ThreadTest {
public static void main(String[] args) {
// 3. 创建Thread类子类的对象
MyThread t1 = new MyThread();
// 4. 通过此对象调用start()
t1.start();
}
}
start()方法的作用：
- 启动当前线程
- 调用当前线程的run()
方式二：实现Runnable接口
- 创建一个实现Runnable接口中的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()方法
// 1. 创建一个实现Runnable接口中的类
class MThread implements Runnable {
// 2. 实现类去实现Runnable中的抽象方法：run()
@Override
public void run() {
System.out.println("runnable线程创建");
}
}
public class ThreadTest1 {
public static void main(String[] args) {
// 3. 创建实现类的对象
MThread mThread = new MThread();
// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(mThread);
// 5. 通过Thread类的对象调用start()方法
t1.start();
}
}
两种方式应该怎么选择呢？？？
- 第一种继承的方式无法显示多继承，可能MyThread类本身有父类，这样不能继承两个父类，而且让一个普通类去继承一个Thread作为父类也比较奇怪。
- 实现的方式天然可以实现一个共享数据的概念，而对于继承需要设置一个静态变量（如果多个线程共享某一个数据，实现的方式是将数据传到构造器中）
所以优先选择实现Runnable接口的方式
方式三：实现Callable接口
方式四：使用线程池
三、线程的优先级
优先级
- MAX_PRIORITY：10
- MIN_PRIORITY：1
- NORM_PRIORITY：5 默认优先级
优先级涉及的方法
- getPriority()：返回线程优先值
- setPriority(int new Priority)：改变线程的优先级
四、线程的生命周期
- 新建：一个Thread类或其子类被声明并创建时
- 就绪：线程被start()之后，此时线程已经具备了运行的条件，等待CPU分配资源
- 运行：获得CPU资源，进入运行状态，run()方法定义了线程的操作和功能
- 阻塞：被人为挂起或者执行输入输出操作时，让出CPU资源并临时终止自己的执行
- 死亡：线程结束或者强制终止或者出现异常导致结束
四、线程安全问题
买票问题
class Window implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0){
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
public class WindowTest{
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
解决方法：当一个线程a在操作数据时，其他线程不能参与进来，直到线程a操作完成数据，其他线程才能开始操作。这种情况即使线程a发生阻塞，也不能改变
在java中，通过同步机制，来解决线程安全的问题
方式一：同步代码块
synchronized(同步监视器) {
需要被同步的代码
}
说明：
- 操作共享数据的代码，即为需要被同步的代码
- 共享数据：多个县城共同操作的变量
- 同步监视器：锁。任何一个类的对象都可以充当锁
要求： 多个线程必须要共用同一把锁
补充： 在使用Runnable实现类中可以使用this充当同步监视器
上述抢票代码需要更改为：
优点：解决了线程安全问题。
不足： 操作同步代码时，只有一个线程参与，其他线程等待，相当于是一个单线程过程，效率较低。
class Window implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
// 此时的this：唯一的对象this
synchorized (this) {
// synchronized (obj) {
if (ticket > 0){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的
class Window implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
// 同步监视器：this
private synchronized void show() {
if (ticket > 0){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
ticket--;
}
}
}
public class WindowTest{
public static void main(String[] args) {
Window w1 = new Window();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
死锁问题
不同的线程分别占用对方的同步资源，都在等待对方先放弃自己需要的同步资源，就形成了线程的思索。
解决方法：
- 专门的算法
- 尽可能少的使用同步资源的定义
- 避免嵌套同步
Lock（锁）
class Windows implements Runnable {
private int tickets = 100;
// 1、实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 2、调用锁定方式lock
lock.lock();
if (tickets > 0){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + tickets);
tickets--;
}else {
break;
}
}finally {
// 3.调用解锁方法unlock()
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Windows w1 = new Windows();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
Synchorized和Lock的异同
不同点：
- synchorized机制在执行完相应的同步代码以后，自动释放同步监视器
- Lock需要手动的启动同步（lock()）,同时结束同步需要手动的实现（unlock()）
sleep和wait的异同
相同点： 执行方法都可以使线程进入阻塞状态
不同点：
- 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
- sleep()在任何地方都可以使用，wait()必须在同步代码快或者同步方法中
- 是否会释放同步监视器：如果两个方法都是用在同步代码块或者同步方法中，sleep()不会释放锁，wait()会释放锁。
8492
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
