多线程

最新推荐文章于 2024-12-01 23:55:34 发布

zclong

最新推荐文章于 2024-12-01 23:55:34 发布

阅读量299

点赞数

分类专栏： java基础文章标签：多线程

本文链接：https://blog.youkuaiyun.com/zclongwork/article/details/78548544

版权

java基础专栏收录该内容

3 篇文章

订阅专栏

创建线程的第一种方式：继承Thread类。

步骤：

定义类继承Thread。
复写Thread类的run方法。目的是将定义代码存储在run方法，让线程运行。（Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。）
调用线程的start方法，
该方法有两个作用：启动线程，调用run方法。
static Thread currentThread():获取当前线程对象。
getName()：获取线程名称。

设置线程名称：setName或者构造函数。

创建线程的第二种方式：实现Runnable接口

步骤：

定义类实现Runnable接口。
覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
通过Thread类建立线程对象。
将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要将Runnable接口的子类对象传递给Thread的构造函数。因为，自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

多线程的实现方式和继承方式区别：

单继承，多实现（如Student继承Person后就不能继承Thread了）

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。
继承Thread：线程代码存放在Thread子类的run方法中。
实现Runnable，线程代码存放在接口子类的run方法中。

多线程安全问题：

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式:
就是同步代码块。

同步代码块

synchronized（对象）
{
    需要被同步的代码
}

对象如同锁。持有锁的线程可以再同步中执行。
没有持有锁的线程即使获得cpu的执行权，因为没有获取锁。

同步的前提：

必须要有两个或者两个以上的线程，
必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：保证了线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。

同步函数

同步函数使用的锁是this
函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
静态同步函数的锁是:方法所在类的字节码文件对象，即：类名.class
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。即类名.class。该对象的类型是Class。

死锁

同步中嵌套同步，应避免死锁的发生。

死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。

死锁代码：

static class MyLock {
    static Object locka = new Object();
    static Object lockb = new Object();
}

class TestRunnable implements Runnable {
    private boolean flag;

     TestRunnable(boolean flag) {
        this.flag = flag;
    }

    public void run() {
        if (flag) {
            while (true) {
                synchronized (MyLock.locka) {
                    System.out.println(Thread.currentThread().getName() + "...if locka ");
                    synchronized (MyLock.lockb) {
                        System.out.println(Thread.currentThread().getName() + "..if lockb");
                    }
                }
            }
        } else {
            while (true) {
                synchronized (MyLock.lockb) {
                    System.out.println(Thread.currentThread().getName() + "..else lockb");
                    synchronized (MyLock.locka) {
                        System.out.println(Thread.currentThread().getName() + ".....else locka");
                    }
                }
            }
        }
    }
}

public void deadLockTest() {
    Thread t1 = new Thread(new TestRunnable(true));
    Thread t2 = new Thread(new TestRunnable(false));
    t1.start();
    t2.start();
}

线程间通讯：
就是多个线程在操作同意个资源，但是操作的动作不同。

等待唤醒机制
wait() notify() notifyAll()
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成显示Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁进行获取。
该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized
lock
unlock
newCondition()

Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();