线程(学习Java第21天)（多线程的两种实现方式、线程安全synchronized、线程同步）

本文链接：https://blog.csdn.net/weixin_42279465/article/details/122991992

一.多线程概念

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程与线程的区别
- 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
- 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

下面内容为了解知识点
- 因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。
- Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。
- 由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

二.线程的创建-继承方式

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。

继承Thread类方式，Java中通过继承Thread类来创建并启动多线程的步骤如下：

- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动该线程


public class MyThread extends Thread {

    public void run(){

        for(int i = 0 ; i < 500 ; i++) {

            System.out.println("重写run方法..."+i);
        }
    }
}

/**
 *  线程: 也是对象
 *  java.lang.Thread类,描述了线程对象
 *  实现多线程程序的方式一:
 *    1: 定义类继承Thread
 *    2: 重写方法run
 *    3: 创建子类对象
 *    4: 子类对象调用方法 start()
 *      线程执行,JVM调用run()
 */

public class ThreadDemo {

    public static void main(String[] args) {

        //3: 创建子类对象

        MyThread myThread = new MyThread();

        //4: 子类对象调用方法 start()

        myThread.start();

        for(int i = 0 ; i < 500 ; i++) {
            System.out.println("main方法..."+i);

        }
    }
}

run()方法和start()方法
- run()方法，是线程执行的任务方法，每个线程都会调用run()方法执行，我们将线程要执行的任务代码都写在run()方法中就可以被线程调用执行。
- start()方法，开启线程，线程调用run()方法。start()方法源代码中会调用本地方法start0()来启动线程：private native void start0()，
- 本地方法都是和操作系统交互的，因此可以看出每次开启一个线程的线程都会和操作系统进行交互。
线程内存图

线程名字的设置和获取
- hread类的方法String getName()可以获取到线程的名字。
- Thread类的方法`setName(String name)`设置线程的名字。
- 通过Thread类的构造方法Thread(String name)也可以设置线程的名字。

public class MyThread  extends Thread{
    public void run(){
        System.out.println("线程名字:"+super.getName());

    }
}

public class Demo {
    public static void main(String[] args) {

        //创建自定义线程对象
        MyThread mt = new MyThread();

        //设置线程名字

        mt.setName("旺财");

        //开启新线程

        mt.start();
    }
}

注意：线程是有默认名字的，如果我们不设置线程的名字，JVM会赋予线程默认名字Thread-0,Thread-1。

获取运行main方法线程的名字
- Demo类不是Thread的子类，因此不能使用getName()方法获取。
- Thread类定义了静态方法static Thread currentThread()获取到当前正在执行的线程对象。
- main方法也是被线程调用了，也是具有线程名字的。


public static void main(String[] args){
    Thread t = Thread.currentThread();
    System.out.println(t.getName());
}

三.线程的创建-实现方式

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

实现Runnable接口方式

- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable{
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);

        }
    }
}

public class Demo {

  public static void main(String[] args) {

        //创建自定义类对象  线程任务对象

        MyRunnable mr = new MyRunnable();

        //创建线程对象
        Thread t = new Thread(mr);
        t.start();

        for (int i = 0; i < 20; i++) {

            System.out.println("main " + i);

        }
    }
}

Thread和Runnable的区别
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
匿名内部类方式创建线程

/**
 *  使用匿名内部类,实现线程程序
 *  1: 继承父类
 *  2: 实现接口
 *
 *  匿名内部类: 取代了实现类,或者子类
 *
 *  格式:
 *    new 父类接口(){
 *        重写父类方法();
 *   }
 */

public class ThreadDemo {

    public static void main(String[] args) {

        //匿名内部类,取代Thread的子类

        //就是在创建他的子类对象

        new Thread(){
            public void run(){

                System.out.println("匿名内部类实现线程");
            }
        }.start();

        //匿名内部类,取代Runnable接口实现类

        Runnable r =  new Runnable(){

            public void run(){

                System.out.println("匿名内部类实现线程_接口方式");

            }

        };

        new Thread(r).start();

        //new Thread( ()-> System.out.println("启动线程") ).start();
    }
}

四.线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

我们通过一个案例，演示线程的安全问题：

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

发现程序出现了两个问题：

- 相同的票数,比如5这张票被卖了两回。
- 不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题引发：线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；

若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

五.线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(**synchronized**)来解决。

同步代码块

同步代码块：线程操作的共享数据进行同步。synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

格式：


synchronized(同步锁){

     需要同步操作的代码
}

同步锁又称为对象监视器。同步锁只是一个概念,可以想象为在对象上标记了一个锁.

锁对象可以是任意类型。

多个线程对象要使用同一把锁。

在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

线程运行至同步代码块的时候，需要判断锁，获取锁，出去同步代码块后要释放锁，增加了很多操作，因此线程安全，程序的运行速度慢！

public class Ticket implements  Runnable{
    //定义票源
    private int tickets = 100;
    private Object object = new Object();
    //在方法run()售票
    /**
     *  通过程序添加线程的休眠方法 10毫秒
     *  出现了数据的安全问题
     *
     *  同步技术保证线程安全
     *  关键字 : synchronized
     *  语法:
     *    synchronized(任意对象){
     *        线程操作的所有共享数据
     *    }
     *    同步代码块
     *    锁: 有锁的线程进入同步代码块执行,执行完毕归还锁
     *    无锁的线程,等待在同步之外
     */
    public void run(){
        while (true) {
          synchronized (object) {
                if (tickets > 0) {
                    //线程先别执行,休息一会
                    try {
                        Thread.sleep(10);
                    } catch (Exception ex) {
                    }
                    System.out.println(Thread.currentThread().getName() + "出售第::" + tickets);
                    tickets--
               }
            }
        }
    }
}

同步方法

同步方法:当一个方法中的所有代码，全部是线程操作的共享数据的时候，可以将整个方法进行同步。使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式：

public synchronized void method(){
    可能会产生线程安全问题的代码
}

/**
 * private void pay() 方法中的所有代码
 * 都是线程操作的共享数据,不使用同步代码块
 * 同步整个方法:方法修饰符上,使用同步关键字
 * 问题:

 *   同步方法中,有对象锁吗,必须有锁
 *   锁是对象,当前对象引用 this
 *   如果方法是静态的,同步中有锁吗
 *   静态方法中,同步锁,不是this
 *   时间差: 静态修饰成员,优先于非静态的成员存在
 *
 *   程序运行需要编译后的文件class
 *   class文件也是对象
 *   静态方法同步中的对,是class文件这个对象
 *   class文件这个对象只能获取,不能创建
 *   固定写法 类名.class  (反射)
 */
public class Ticket implements  Runnable{
    //定义票源
    private static int tickets = 100;
    //private Object object = new Object();
    public void run(){
        while (true) {
            pay();
        }
    }
    //定义方法,实现售票,run()调用

    private synchronized  void pay(){

            if (tickets > 0) {
                //线程先别执行,休息一会
                try {
                    Thread.sleep(10);
                } catch (Exception ex) {
                }
                System.out.println(Thread.currentThread().getName() + "出售第::" + tickets);
                tickets--
        }
    }
}