小白程序员的Java线程学习笔记

最新推荐文章于 2024-11-04 22:26:34 发布

不做沸物

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量179

点赞数 3

分类专栏： Java 多线程学习笔记文章标签： java 多线程 thread

本文链接：https://blog.csdn.net/qq_42532132/article/details/106911712

版权

学习笔记同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

Java

1 篇文章 0 订阅

订阅专栏

多线程

1 篇文章 0 订阅

订阅专栏

线程总结

前言：关于进程和线程

进程：进程是程序的一次执行过程，或是正在运行的一个程序。

线程：线程是进程的一个实体，是进程的一条执行路径。

一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。系统在运行时会为每个进程分配不同的内存区域，多个线程操作共享的系统资源可能就会带来安全的隐患。

一、线程的创建方式

方式一：继承Thread类

一、最基本的方式

具体步骤：

1.创建Thread类的子类；

2.重写Thread的run()方法：将当前线程要执行的操作声明在run()方法内；

3.将创建的Thread类的子类实例化；

4.通过Thread类的子类对象调用start()方法，启动线程（启动线程后，会执行run()方法）。

例题：创建一个分线程，遍历100以内的偶数

public class ThreadTest {
    public static void main(String[] args) {
        //步骤三：将创建的Thread类的子类实例化
        EvenNum e = new EvenNum();
        //步骤四：通过Thread类的子类对象调用start()方法启动分线程
        e.start();
    }
}

//步骤一：创建Thread类的子类
class EvenNum extends Thread{
    public EvenNum() {
    }
    //步骤二：重写Thread类中的run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++){
            if (i%2 == 0){
                System.out.println(Thread.currentThread().getName() + "偶数：" + i);
            }
        }
    }
}

注意：分线程对象的创建和启动工作，是由主线程完成的。

问题一：能否直接通过e.run()命令的方式启动线程，并执行相关逻辑？------------不可以。

解释：run()方法只是Thread类中的一个普通方法，直接调用，会导致程序中仍然只有主线程，但是如果调用start()方法启动线程，才能真正实现多线程。

public void run() {
    if (this.target != null) {
        this.target.run();
    }
}

public synchronized void start() {
        if (this.threadStatus != 0) {
            throw new IllegalThreadStateException();
        } else {
            this.group.add(this);
            boolean started = false;

            try {
                this.start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        this.group.threadStartFailed(this);
                    }
                } catch (Throwable var8) {
                }

            }

        }
    }

问题二：再启动一个分线程，用于遍历100以内的偶数，能否让已经start()的线程再次执行start()方法？--------不能

解释：每个线程只能被start()一次，一旦被多次调用start()方法，会报异常：IllegalThreadStateException

二、继承Thread类创建方式中的其他方式：匿名内部类

public class ThreadTest1 {//遍历100以内的偶数
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    if (i % 2 == 0) {
                        //currentThread()表示当前线程
                        System.out.println(Thread.currentThread().getName() + "偶数：" + i);
                    }
                }
            }
        }.start();
    }
}

例题：三个窗口售票，总票数为100张，售完即止（会出现相同票数等线程不安全问题）

public class ThreadTest3 {
    public static void main(String[] args) {
        Window window1 = new Window();
        Window window2 = new Window();
        Window window3 = new Window();

        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");

        window1.start();
        window2.start();
        window3.start();
    }
}

class Window extends Thread{
    private static int ticketNum = 100;

    public  int getTicketNum() {
        return ticketNum;
    }

    @Override
    public void run() {
        while(getTicketNum() > 0){
            ticketNum--;
            System.out.println(Thread.currentThread().getName() + "售出，剩余票数：" + ticketNum);
        }
    }
}

方式二：实现Runnable接口

一、最基本的方式

具体步骤：

1.提供Runnable的实现类；

2.实现接口中的抽象方法：run()：将当前线程要执行的操作声明在run()中；

3.将Runnable的实现类实例化，即创建实现类对象；

4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象；

5.通过Thread类的对象调用start()方法，启动线程（启动线程后，会执行run()方法）。

例题：遍历100以内的偶数

public class RunnableTest {
    public static void main(String[] args) {
        //步骤三：创建实现类的对象
        EvenNum1 evenNum1 = new EvenNum1();
        //步骤四：将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(evenNum1);
        //通过Thread()类的对象调用start()方法
        thread.start();
    }
}

//步骤一：创建Runnable接口的实现类
class EvenNum1 implements Runnable {
    //步骤二：实现Runnable接口中的run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "偶数：" + i);
            }
        }
    }
}

问题：为什么通过start()调用的是Thread类中的run()方法，此run()方法怎么就表现为对Runnable实现类中的run()方法的调用。

解释：

例题：三个窗口售票，总共100张票，售完即止

public class RunnableTest2 {
    public static void main(String[] args) {
        Window1 window1 = new Window1();

        Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window1 implements Runnable {
    private static int ticketNum = 100;

    @Override
    public void run() {
        while (ticketNum > 0) {
            ticketNum--;
            System.out.println(Thread.currentThread().getName() + "售出，剩余票数：" + ticketNum);
        }
    }
}

二、匿名实现类的匿名对象的方式

public class RunnableTest3 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    if (i % 2 == 0) {
                        System.out.println(Thread.currentThread().getName() + "偶数：" + i);
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <= 100; i++) {
                    if (i % 2 != 0) {
                        System.out.println(Thread.currentThread().getName() + "奇数：" + i);
                    }
                }
            }
        }).start();
    }
}

两种方式（继承Thread类和实现Runnable接口）的对比

相同点：都要进行run()方法的重写；启动线程都需要调用Thread类中的start()方法。

对比：①类可以实现多个接口；但是只能继承一个符类；②实现的方式更方便的来处理有共享数据的情况。

结论：实现Runnable的方式要优于继承Thread类的方式

联系：public class Thread implements Runnable

二、现场的常用方法

start()：启动线程，调用线程中的run()；

run()：将线程要执行的操作声明在该方法中；

currentThread()：获取执行当前代码的线程；

getName()：获取当前线程的名字；

setName()：设置当前线程的名字；

sleep(long milisecond)：一旦执行此方法，当前线程就阻塞指明的毫秒数；

yield()：每当执行此方法时，线程主动释放cpu的执行权；

join()：在线程a中调用线程b的join()方法，此时线程a进入阻塞状态，知道线程b执行结束以后，才结束线程a的阻塞状态，线程a继续执行；

isAlive()：判断当前线程是否还存活。

线程的优先级：

设置和获取线程的优先级：设置：setPriority(int priority)；获取：getPriority()

优先级的等级：

MIN_PRIORITY：1

NORM_PRIORITY：5

MAX_PRIORITY：10

调度策略：高优先级的线程要抢占低优先级线程的策略；高优先级的线程只是从概率上来讲，更大概率的比低优先级先执行。并不是100%的一定优先于低优先级线程执行。

三、线程的生命周期

线程共有如下几个状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING

在Thread类内部定义了线程生命周期的内部类：State

public enum State {
    /**
     *Thread state for a thread which has not yet started.
     */        
    NEW,
  
    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}

作为尚硅谷康哥的学生很自豪！

四、线程安全问题

就如前言所说的一样：多个线程操作共享的系统资源可能就会带来安全的隐患，这就是线程安全问题。

所以需要线程同步。

如何解决线程的安全问题：

同步机制（synchronized）：

同步代码块和同步方法。

同步监视器：任何一个类的对象都可以充当，但是要求多个线程必须共享同步监视器。

共享数据：多个线程共同操作的变量。

操作共享数据的代码，不多不少。

Lock锁。

线程同步以后的好处。-------解决了线程的安全问题，体现了数据的一致性。

线程同步以后的弊端。-------并发性降低，执行效率降低。

1.同步代码块

synchronized(同步代码块){

//需要被同步的代码

}

说明：①：需要被同步的代码，即为操作共享数据的代码。②：何为共享数据？多个线程共同操作的数据。比如窗口售票中ticket。③：同步监视器，俗称锁。任何一个类的对象，都可以充当同步监视器。

要求：多个线程，必须共用一个同步监视器。

2.同步方法

说明：①：同步方法，也有同步监视器，只不过是默认的同步监视器，不能显式定义。②：对于非静态的同步方法，同步监视器时this；对于静态的同步方法，同步监视器是当前类本身。

3.Lock锁的使用

public class WindowTest {
    public static void main(String[] args) {
        Window3 window3 = new Window3();

        Thread t1 = new Thread(window3);
        Thread t2 = new Thread(window3);
        Thread t3 = new Thread(window3);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Window3 implements Runnable{
    private int ticketNum = 100;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try{
                lock.lock();
                if (ticketNum > 0){
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketNum--;
                    System.out.println(Thread.currentThread().getName() + "售出，剩余票数：" + ticketNum);

                }else {
                    break;
                }

            } finally {
                lock.unlock();
            }

        }
    }
}

五、线程的死锁问题

线程的同步机制带来的问题：死锁

1.不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

抽象理解：即两个人吃饭，只有一双筷子，两人分别拿了一根，都在等待对方的另外一根筷子，僵持不下们一直等待。

2.出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续运行。

3.编程时，一定要避免死锁。

六、线程的通信

线程通信涉及到三个方法：

wait()：当执行到此方法时，当前的线程就会进入阻塞状态，同时释放对同步监视器的调用。需要被唤醒，才可以继续执行。

notify()：当执行到此方式时，就会唤醒被wait的一个线程。如果有多个被wait的线程，则唤醒优先级高的那个。

notifyAll()：当执行到此方式时，就会唤醒所有被wait的线程。

关于这三个方法的说明：

wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中、不能再Lock中使用；

wait()、notify()、notifyAll()三个方法的调用者时同步监视器，否则，报java.lang.IllegalMonitorStateException；

wait()、notify()、notifyAll()三个方法定义在java.lang.Object类中。

例题：使用两个线程打印1-100.线程1、线程2交替打印。

public class CommunicationTest {
    public static void main(String[] args) {
        PrintNum printNum = new PrintNum();
        Thread t1 = new Thread(printNum);
        Thread t2 = new Thread(printNum);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

class PrintNum implements Runnable {
    private int num = 1;
    private Object object = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (object) {
                object.notifyAll();//唤醒被wait的线程
                if (num <= 100) {
                    try {
                        Thread.sleep(50);//不会释放同步监视器
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "打印：" + num);
                    num++;

                    try {
                        object.wait();//让线程进入等待状态，执行此方法，会释放同步监视器
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                } else {
                    break;
                }


            }
        }
    }
}

问题：sleep()和wait()的异同？

相同点：一旦执行，都会使得当前线程结束执行状态，进入等待状态。

不同点：定义方法所属的类：sleep()：Thread中定义。 wait()：Object中定义

使用范围不同：sleep()可以在任何需要使用的位置被调用；wait()：必须使用在同步代码块或同步方法中

都在同步结构中使用的时候，是否释放同步监视器的操作不同； sleep()：不会释放同步监视器；wait()：会释放同步监视器。

结束等待的方式不同：sleep()：指定时间一到就结束阻塞；wait()：需要被唤醒，进而结束阻塞。

释放锁的操作：

当前线程的同步方法、同步代码块执行结束。

当前线程在同步代码块、同步方法中遇到break、return终止了改代码块、该方法的继续执行。

当前线程在同步代码块、同步方法中出现了为处理的Error或Exception，导致异常结束。

当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作：