JavaSE学习总结第23天_多线程1

 

23.01  多线程程序的引入

如果一个程序只有一个执行流程，所以这样的程序就是单线程程序。

如果一个程序有多条执行流程，那么，该程序就是多线程程序。

23.02  进程概述及多进程的意义

要想说线程，首先必须得知道进程，因为线程是依赖于进程存在的

进程:正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

 

多进程意义:多进程的作用不是提高执行速度，而是提高CPU的使用率

单进程计算机只能做一件事情。而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程)，所以我们常见的操作系统都是多进程操作系统。

比如:Windows，Mac和Linux等，能在同一个时间段内执行多个任务。

 

对于单核计算机来讲，游戏进程和音乐进程不是同时运行的，因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，且切换速度很快，所以，我们感觉游戏和音乐在同时进行，其实并不是同时执行的。

23.03  线程概述及多线程的意义

在一个进程内部又可以执行多个任务，而这每一个任务就可以看成是一个线程。线程是程序中单个顺序的控制流，是程序使用CPU的基本单位。

线程:

是进程中的单个顺序控制流，是一条执行路径

一个进程如果只有一条执行路径，则称为单线程程序。

一个进程如果有多条执行路径，则称为多线程程序。

多线程意义:   多线程的作用也不是提高执行速度，而是为了提高应用程序的使用率。

多个线程共享同一个进程的资源(堆内存和方法区)，但是栈内存是独立的，一个线程一个栈。所以他们仍然是在抢CPU的资源执行。一个时间点上只有能有一个线程执行。而且谁抢到，这个不一定，所以，造成了线程运行的随机性。

23.04  并行和并发的区别

注意两个词汇的区别:并行和并发

并行是逻辑上同时发生，指在某一个时间内同时运行多个程序

并发是物理上同时发生，指在某一个时间点同时运行多个程序

23.05  Java程序运行原理和JVM的启动是多线程的吗

Java程序运行原理:java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。

由于JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的

23.06  实现多线程及多线程方式1的思路

由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来。而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。Java是不能直接调用系统功能的，但是Java可以去调用C/C++写好的程序来实现多线程程序。由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，然后提供一些类供我们使用。我们就可以实现多线程程序了。

Java提供的类 Thread

通过查看API，知道有2中方式实现多线程程序。

方式1:继承Thread类

步骤:

1:自定义类MyThread继承Thread类。

2:MyThread类重写run()方法

3:创建对象

4:启动线程

23.07  多线程方式1的代码实现

例:

public class Practice 
{
    public static void main(String[] args)
    {
        //创建对象
        //MyThread mt = new MyThread();
        //run()方法直接调用其实就相当于普通的方法调用,所以看到的是单线程的效果
        //要想看到多线程的效果，就必须使用另一个方法:start()
        //mt.run();
        // 创建两个线程对象
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        my1.start();
        my2.start();
        
    }
}
//继承Thread类
class MyThread extends Thread 
{
    //重写run()方法
    @Override
    public void run() 
    {
        // 一般来说，被线程执行的代码肯定是比较耗时的。所以用循环改进
        for (int x = 0; x < 200; x++) 
        {
            System.out.println(x);
        }
    }
}

run()和start()的区别

run():仅仅是封装被线程执行的代码，直接调用是普通方法

start():首先启动了线程，然后再由jvm去调用该线程的run()方法

继承Thread类的类为什么要重写run()方法?

不是类中的所有代码都需要被线程执行的。而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。

23.08  获取和设置线程对象名称

public final String getName():返回该线程的名称

public final void setName(String name):改变线程名称，使之与参数 name 相同。

例:

public class Practice 
{
    public static void main(String[] args)
    {
//        MyThread my1 = new MyThread();
//        MyThread my2 = new MyThread();
//
//        //调用方法设置名称
//        my1.setName("线程1");
//        my2.setName("线程2");
//        //启动线程
//        my1.start();
//        my2.start();
        
        //带参构造方法给线程起名字
         MyThread my1 = new MyThread("线程1");
         MyThread my2 = new MyThread("线程2");
         my1.start();
         my2.start();
         
        //获取main方法所在的线程对象的名称
        //public static Thread currentThread():返回当前正在执行的线程对象
        System.out.println(Thread.currentThread().getName());
        
    }
}
class MyThread extends Thread 
{
    
    public MyThread()
    {
        super();
    }
    
    public MyThread(String name) 
    {
        super(name);
    }
    @Override
    public void run() 
    {
        for (int x = 0; x < 200; x++) 
        {
            System.out.println(getName()+":"+x);
        }
    }
}

运行结果:

main
线程1:0(省略部分结果)
线程2:8(省略部分结果)

通过Thread类的getName( )方法可以获取线程的名称，默认的命名方式是:Thread-编号(从0开始)

为什么名称是:Thread-编号?

看源码:

class Thread
{
    private char name[];
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() 
    {
        return threadInitNumber++;
    }
    public Thread() 
    {
        init(null, null, "Thread-" + nextThreadNum(), 0);
    }
    public final String getName() 
    {
        return String.valueOf(name);
    }
    private void init(ThreadGroup g, Runnable target, String name,long stackSize) 
    {
        init(g, target, name, stackSize, null);
    }
    
    private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc) 
    {
        //省略部分代码
        this.name = name.toCharArray();
    }
}

23.09  线程调度及获取和设置线程优先级

线程调度:

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。那么Java是如何对线程进行调用的呢？

线程有两种调度模型:

分时调度模型:所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型:优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。

Java使用的是抢占式调度模型。

 

设置和获取线程优先级

public final int getPriority():返回线程的优先级。

public final void setPriority(int newPriority):更改线程的优先级。

例:

public class Practice 
{
    public static void main(String[] args)
    {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        MyThread my3 = new MyThread();
        
        //设置优先级，最小为1，最大为10
        my3.setPriority(9);
        //获取优先级，默认为5
        System.out.println(my1.getPriority());//5
        System.out.println(my2.getPriority());//5
        System.out.println(my3.getPriority());//9
        
        my1.start();
        my2.start();
        my3.start();//获取的 CPU 时间片相对多一些
    }
}
class MyThread extends Thread 
{
    @Override
    public void run() 
    {
        for (int x = 0; x < 200; x++) 
        {
            System.out.println(getName()+":"+x);
        }
    }
}

23.10  线程控制之休眠线程

public static void sleep(long millis)throws InterruptedException

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

例:

class MyThread extends Thread 
{
    @Override
    public void run() 
    {
        for (int x = 0; x < 5; x++) 
        {
            System.out.println(getName()+":"+x+":"+new Date());
            try 
            {
                //休眠1秒
                Thread.sleep(1000);
            } 
            catch (InterruptedException e) 
            {
                e.printStackTrace();
            }
        }
    }
}

23.11  线程控制之加入线程

public final void join()throws InterruptedException

等待该线程终止。

例:

public class Practice 
{
    public static void main(String[] args)
    {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        MyThread my3 = new MyThread();
        
        my1.setName("线程1");
        my2.setName("线程2");
        my3.setName("线程3");
        
        my1.start();
        try 
        {
            //等待线程1线程，线程1运行完成后，线程2线程3开始争夺资源
            my1.join();
        } 
        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }
        my2.start();
        my3.start();
    }
}

23.12  线程控制之礼让线程

public static void yield()

暂停当前正在执行的线程对象，并执行其他线程。

例:

class MyThread extends Thread 
{
    @Override
    public void run() 
    {
        for (int x = 0; x < 100; x++) 
        {
            System.out.println(getName()+":"+x);
            //暂停当前线程，并执行其他线程，不能保证机会均等
            Thread.yield();
        }
    }
}

23.13  线程控制之守护线程

public final void setDaemon(boolean on)

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。

例:

public class Practice 
{
    public static void main(String[] args)
    {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        
        my1.setName("线程1");
        my2.setName("线程2");
        
        //将该线程标记为守护线程
        my1.setDaemon(true);
        my2.setDaemon(true);
        
        my1.start();
        my2.start();
        
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 20; i++) 
        {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

23.14  线程控制之中断线程

1.public void interrupt() 中断线程。

2.public final void stop()  停止线程，已过时。该方法具有固有的不安全性。

例:

public class Practice 
{
    public static void main(String[] args)
    {
        MyThread my = new MyThread();
        my.setName("线程1");
        my.start();
        try 
        {
            Thread.sleep(2000);
            //2秒后终止my线程，使用stop()后面的语句都不会执行
            //my.stop();该方法已过时，具有不安全性
            my.interrupt();//后面的语句会执行
        } 
        catch (InterruptedException e) 
        {
            e.printStackTrace();
        }
    }
}

23.15  线程生命周期图解

23.16  多线程方式2的思路及代码实现

步骤:

1:自定义类MyRunnable实现Runnable接口

2:重写run()方法

3:创建MyRunnable类的对象

4:创建Thread类的对象，并把3步骤的对象作为构造参数传递

public class Practice 
{
    public static void main(String[] args)
    {
        // 创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        // 创建Thread类的对象，并把C步骤的对象作为构造参数传递
        // 构造方法 Thread(Runnable target)
        // Thread t1 = new Thread(my);
        // Thread t2 = new Thread(my);
        // t1.setName("小明");
        // t2.setName("小红");

        // 构造方法 Thread(Runnable target, String name)
        Thread t1 = new Thread(my, "小明");
        Thread t2 = new Thread(my, "小红");

        t1.start();
        t2.start();
    }
}
class MyRunnable implements Runnable
{
    @Override
    public void run() 
    {
        for (int i = 0; i < 200; i++) 
        {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

23.17  实现接口方式的好处

1.可以避免由于Java单继承带来的局限性。

2.适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想。

23.18  继承Thread类的方式卖电影票案例

某电影院电影票共有100张，有3个售票窗口售票，请设计一个程序模拟该电影院售票。

public class Practice 
{
    public static void main(String[] args)
    {
        sellTicket st1 = new sellTicket();
        sellTicket st2 = new sellTicket();
        sellTicket st3 = new sellTicket();
        
        st1.setName("窗口1");
        st2.setName("窗口2");
        st3.setName("窗口3");
        
        st1.start();
        st2.start();
        st3.start();
        
    }
}
class sellTicket extends Thread
{
    // 定义100张票
    // private int tickets = 100;
    // 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
    private static int tickets = 100;

    @Override
    public void run() 
    {
        // 定义100张票
        // 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
        // int tickets = 100;

        // 是为了模拟一直有票
        while (true) 
        {
            if (tickets > 0) 
            {
                System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
            }
        }
    }
}

23.19  实现Runnable接口的方式卖电影票案例

public class Practice 
{
    public static void main(String[] args)
    {
        SellTicket st = new SellTicket();
        
        new Thread(st, "窗口1").start();
        new Thread(st, "窗口2").start();
        new Thread(st, "窗口3").start();
    }
}
class SellTicket implements Runnable 
{
    // 定义100张票
    private int tickets = 100;

    @Override
    public void run() 
    {
        while (true) 
        {
            if (tickets > 0) 
            {
                System.out.println(Thread.currentThread().getName() + "正在出售第"
                        + (tickets--) + "张票");
            }
        }
    }
}

23.20  买电影票出现了同票和负数票的原因分析

例:

class SellTicket implements Runnable 
{
    // 定义100张票
    private int tickets = 100;

    @Override
    public void run() 
    {
        while (true) 
        {
            //该语句存在安全隐患，如果当票数还剩1张的时候，此时4个线程可能
            //由于CPU的随机切换而通过该语句，当执行下面的语句时就会出现负的
            //票数，同时也可能出现相同的票卖出多次
            if (tickets > 0) 
            {
                try 
                {
                    Thread.sleep(10);
                } 
                catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第"
                        + (tickets--) + "张票");
            }
        }
    }
}

相同的票出现多次:CPU的一次操作必须是原子性的

出现了负数的票:随机性和延迟导致的

23.21  线程安全问题的产生原因分析

线程安全问题产生的原因:

1.多个线程在操作共享的数据

2.操作共享数据的线程代码有多条

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算,就会导致线程安全问题的产生

23.22  同步代码块的方式解决线程安全问题

思想:把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，其他线程不能来执行。Java提供了:同步机制。

同步代码块:

synchronized(对象)

{需要同步的代码;}

例:

public class SellTicket implements Runnable 
{
    // 定义100张票
    private int tickets = 100;
    //创建锁对象
    private Object obj = new Object();
    @Override
    public void run() 
    {
        while (true) 
        {
            //锁对象必须是同一个
            synchronized(obj)
            {
                if (tickets > 0) 
                {
                    try 
                    {
                        Thread.sleep(100);
                    } 
                    catch (InterruptedException e) 
                    {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第"
                            + (tickets--) + "张票");
                }
            }
        }
    }
}

23.23  同步的特点及好处和弊端

同步的前提:多个线程且多个线程使用的是同一个锁对象

同步的好处:同步的出现解决了多线程的安全问题

同步的弊端:当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

23.24  同步代码块的锁及同步方法应用和锁的问题

同步方法就是把同步关键字加到方法上

例:

//同步方法
    private synchronized void sellTicket()
    {
        if (tickets > 0) 
        {
            try 
            {
                Thread.sleep(100);
            } 
            catch (InterruptedException e) 
            {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第"
                    + (tickets--) + "张票");
        }
    }

1.同步代码块的锁对象是任意对象

2.同步函数使用的锁是this

3.静态的同步函数使用的锁是该函数所属的字节码文件对象可以用getClass方法获取，也可以用当前类名.class表示

23.25  以前的线程安全的类回顾

Collections中让集合同步功能

例:

// public static <T> List<T> synchronizedList(List<T> list)
List<String> list1 = new ArrayList<String>();// 线程不安全
List<String> list2 = Collections.synchronizedList(new ArrayList<String>()); // 线程安全