JavaSE 第十三章

2021-09-07 21:43:03

1、基本概念

程序：为了完成特定任务，用某种语言编写的一组指令的集合。是一段静态的代码，静态对象。

进程：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程。有他自身的产生，存在和消亡的过程。【生命周期】程序是静态的，进程是动态的。进程做为资源的分配单位，系统在运行时会为每个进程分配不同的内存区域。

线程：线程是程序的执行单元。是程序使用CPU的最基本单位。一个进程的执行，是靠线程来走的。

程序可以进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程做为调度和执行的单位，每个线程拥有独立的运行栈和程序计算器，线程切换的开销小。一个进程中的多个线程共享相同的内存单元|内存地址。他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简洁，高效。但多个线程操作共享的系统资源可能会带来安全隐患。

单核CPU和多核CPU：单核CPU，其实是一种假的多线程。因为再一个时间单元内，也只能执行一个线程的任务。因为CPU时间单元特别短，因此感觉不出来。多核的话，才能更好的发挥多线程的效率。一个java程序java.exe,至少三个线程main()主线程，gc()垃圾回收线程，异常处理线程。如果发生异常，会影响主线程。

并行域并发：并行：多个CPU同时执行多个任务。也就是多人同时做不同的事情。

并发：一个CPU(采用时间片)同时执行多个任务。比如，秒杀，多人做同一件事。

多线程的优点：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍徐多线程呢？多线程的优点：1>提供应用程序的响应，对图形化界面更有意义，可增强用户体验。提供计算机系统CPU的利用率。改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利用理解和修改。

什么时候需要多线程呢？程序需要同时执行两个或多个任务

程序需要实现一些需要等待的任务时，如用户输入，文件读写操作，网络操作，搜索等。

需要一些后台执行的程序时。

2、线程的创建和使用

之前的程序都是单线程的。

方式一: JAVA语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现

public class MyThread01 extends Thread {    @Override    public void run() {   for(int i=1;i<=100;i++) {   System.out.println(Thread.currentThread().getName()+"---"+i);   }   } }  public class MyThread01Test {        public static void main(String[] args) {        MyThread01 thread01 = new MyThread01();        thread01.setName("线程1");        //thread01.run();//不会启动线程的，现在的程序还是单线程的程序        thread01.start();//启动线程                MyThread01 thread02 = new MyThread01();        thread02.setName("线程2");        thread02.start();//启动线程                thread01.start();//启动线程                for(int i=1;i<=100;i++) {       System.out.println(Thread.currentThread().getName()+":"+i);       }   } }

Thread类的特点：每个线程都说通过某个特定的Thread对象的run()方法来完成操作的，经常把run() 方法的主体称为线程体。我们再使用的时候，是通过调用start()方法来启动这个线程的。一个线程对象只能调用一次start()方法启动线程。如果重复调用就会抛出异常"IllegalThreadStateException"

方式二：实现Runnable接口

public class MyThread02 implements Runnable {
    private String name;
    public MyThread02(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name + ":" + i);
        }
    }
}
public static void main(String[] args) {
        MyThread02 thread01 = new MyThread02("线程01");
        MyThread02 thread02 = new MyThread02("线程02");
        Thread t1 = new Thread(thread01);
        Thread t2 = new Thread(thread02);
        t1.start();
        t2.start();
    }

3、线程状态

新建(New)：在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，他已经有了相应的内存空间和其他资源，但还不处于可运行状态。

就绪(Runnable)：新建线程对象后，可调用线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务，这表名他已经具备了运行条件

运行(Running)：当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

阻塞(Blocked)：一个正在执行的线程在某些特殊情况下，如被认为挂起或需要执行耗时的输入/ 输出操作时，会让出CPU并暂时终止自己的行为，进入堵塞状态，在可执行状态下，如果调用 sleep(),suspend().wait()等方法，线程将进入堵塞状态。堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被消除后，线程才可以转入就绪状态。线程调用了sleep()方法主动放弃所占用的处理器资源。线程调用了一个阻塞式IO方法,在该方法返回之前,该线程被阻塞。线程试图获得一个同步监视器,但该同步监视器正被其它线程所持有。线程在等待某个通知(notify)。

死亡(Dead)：线程调用stop()方法时或run()方法执行结束后，处于死亡状态。处于死亡状态的线程不具备继续运行的能力。

一些方法：

1>join方法

public class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
    System.out.println(Thread.currentThread().getName()+ ":"+i);
        }
    }
}
public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread th1 = new Thread(thread, "线程1");
        Thread th2 = new Thread(thread, "线程2");
        Thread th3 = new Thread(thread, "线程3");
        th1.start();
        try {
            th1.join();//等待th1运行完毕后，其他线程才执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        th2.start();
        th3.start();
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

2> sleep方法

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

public class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+ ":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread th1 = new Thread(thread, "线程1");
        th1.start();
        for(int i=1;i<=100;i++){
        System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

3>Interrupt 线程被中断

public class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("开始执行："+new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("线程被中断");
        }
        System.out.println("程序结束:"+new Date());
    }
}

public class MyThreadTest {
    
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread th1 = new Thread(thread, "线程1");
        th1.start();
        try {
            Thread.sleep(2000);
            th1.interrupt();//线程直接被中断了。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4> yield

暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

public class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
    System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread run = new MyThread();
        Thread thread = new Thread(run, "线程1");
        thread.start();
        for(int i=0;i<100;i++){
            String name = Thread.currentThread().getName();
            System.out.println(name+":"+i);
            Thread.yield();
        }
    }
}

5>join方法

public class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyThredTest {
    public static void main(String[] args) {
        MyThread run = new MyThread();
        Thread th1 = new Thread(run, "线程1");
        Thread th2 = new Thread(run, "线程2");
        Thread th3 = new Thread(run, "线程3");
        th1.start();
        try {
            th1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        th2.start();
        th3.start();
    }
}

6>线程的优先级

线程默认优先级是5，可以自己设置线程的优先级。通过，setPriority()方法来设置线程的优先级。优先级的范围是1-10.线程优先级高仅仅表示线程获取CPU时间片的几率高，但是要在次数比较多，或者多此运行时才能看比较好的效果。

线程分为两类，一类是守护线程，一类是用户线程。他们在几乎每个方面都说相同的，唯一的区别是判断JVM何时离开。守护线程是用来服务用户线程的。通过在start()方法前调用

thread.setDaemon(true)可以把一个用户线程变成守护线程。Java垃圾回收就是一个典型的守护线程。弱JVM中都是守护线程，当前JVM将退出。

public static void main(String[] args) {
        MyThread run = new MyThread();
        Thread th1 = new Thread(run, "线程1");
        Thread th2 = new Thread(run, "线程2");
        Thread th3 = new Thread(run, "线程3");
        th1.setPriority(10);
        th3.setPriority(1);
        th1.start();
        th2.start();
        th3.start();
    }

4、同步域死锁

创建三个窗口买票，总票数为60张票。按照之前的代码，会发现代码出现问题，又相同的票或者负数出现。出现问题的原因是当某个线程操作车票的过程中，操作尚未完成，其他线程进入，也操作了该车票。如何解决？当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程a操作完成，其他线程才可以操作。可以采用同步解决该问题。

synchronized(同步监视器){
        //需要被同步的代码
}

操作共享数据的代码，即为需要被同步的代码，不能多包含也不能少包含。

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

同步监视器：俗称，锁。任何一个类的对象，都可以充当锁，但是要去必须多个线程公用一把锁。

public class Tickets implements Runnable {
    private static int num = 60;
    
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
                synchronized (this) {
                    if (num <= 0) {
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() +   "再售" + num);
                    num--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TicketsTest {
    
    public static void main(String[] args) {
        
        Tickets run = new Tickets();
        Thread th1 = new Thread(run,"窗口1");
        Thread th2 = new Thread(run,"窗口2");
        Thread th3 = new Thread(run,"窗口3");
        th1.start();
        th2.start();
        th3.start();
    }
}

同步的特点：前提：多个线程。

解决问题的时候要注意:多个线程使用的是同一个锁对象。

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

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

synchronized：同步，需要被同步的代码。

同步方法，仍然需要同步监视器，只是不需要显示声明

非静态的同步方法，同步监视器是this

静态的同步方法，同步监视器是当前类本身。

public class Singleton{
    static Singleton singleton;
    
    private Singleton(){
        
    }
    
    public synchronized static Singleton getInstance(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

public class Singleton{
    static Singleton singleton;
    
    private Singleton(){
        
    }
    
    public static Singleton getInstance(){
        if(singleton==null){
            synchronized(Singletion.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

死锁 : 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁。出现死锁后，不会出现异常，不会出现提升，只是所有的线程都处于阻塞状态，无法继续。解决办法：专门的算法，原则。尽量减少同步资源的定义，尽量避免嵌套同步。

public class DeadLock {
    static String s1="hello";
    static String s2 = "world";
    public static void main(String[] args) {
        Lock1 lock1 = new Lock1();
        Thread t1 = new Thread(lock1);
        
        Lock2 lock2 = new Lock2();
        Thread t2 = new Thread(lock2);
        
        t1.start();
        t2.start();
    }
}

public class Lock2 implements Runnable{
    @Override
    public void run() {
        while(true){
            try {
                System.out.println("Lock2执行");
                synchronized (DeadLock.s2) {
                    System.out.println("Lock2持有s2的锁");
                    Thread.sleep(3000);
                    synchronized (DeadLock.s1) {
                        System.out.println("Lock2持有s1锁");
                    }
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
public class Lock1 implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("Lock1执行");
            try {
                synchronized (DeadLock.s1) {
                    System.out.println("Lock1持有s1的锁");
                    Thread.sleep(3000);
                    synchronized (DeadLock.s2) {
                        System.out.println("Lock1持有s2锁");
                    }
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

如何避免死锁呢？加锁顺序（线程按照一定的顺序加锁）。加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）。死锁检测。

Lock(锁): 从JDK5.0开始，java提供了更强大的线程同步机制。通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当。该接口是控制多个线程对共享资源进行访问的公交。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock接口，他拥有与synchronized相同的并发性盒内存语义，再实现线程安全的控制中，比较常用的RenntrantLock可以显示的加锁和释放锁。

class Window implements Runnable{
    
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try{
                lock.lock();
                if(ticket > 0){
                    //2.调用锁定方法lock()
                    System.out.println(Thread.currentThread().getName() +"：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    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("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized与lock的异同：二者都可以解决线程安全问题。synchronized机制再执行完相应的同步代码以后，自动的释放同步监视器。Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

5、线程之间的通信


package com.openlab.test;

public class PrintNum implements Runnable{
    static int i=1;
    @Override
    public void run() {
        
        while(true){
            
            try {
                Thread.sleep(100);
                
                // wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (this){
                if(i>100){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
                i++;
                try {
                    wait(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class PrintNumTest{
    public static void main(String[] args) {
        PrintNum run = new PrintNum();
        Thread th1 = new Thread(run,"线程1");
        Thread th2 = new Thread(run,"线程2");
        Thread th3 = new Thread(run,"线程3");
        th1.start();
        th2.start();
        th3.start();
    }
}

package com.openlab.test;

public class PrintNum implements Runnable{
    static int i=1;
    @Override
    public void run() {
        
        while(true){
            
            try {
                 Thread.sleep(100);
                
                // wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
             }
        synchronized (this){
            notify();
            if(i>100){
                break;
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
            i++;
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        }
    }
}
class PrintNumTest{
    public static void main(String[] args) {
        PrintNum run = new PrintNum();
        Thread th1 = new Thread(run,"线程1");
        Thread th2 = new Thread(run,"线程2");
        Thread th3 = new Thread(run,"线程3");
        th1.start();
        th2.start();
        th3.start();
    }
}

wait方法，一旦执行，线程进入阻塞状态，并释放对象的锁。

notify方法，一旦执行，会唤醒等待的线程，如果有多个线程，唤醒优先级高的

notifyAll方法，会唤醒所有等待的线程。

这三个方便必须再同步方法或同步代码块中使用。

sleep和wait方法的异同？相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

不同点：两个方法声明的位置不同，Thread中是sleep方法。Object类中是wait方法。

调用的范围不同：sleep方法可以再任何需要的场景下调用。wait必须在同步代码块中运行。如果两个方法都用在同步代码块或同步方法中，sleep不会释放对象锁。wait方法会释放锁。

生产者与消费者

/**
* 工厂
* @author Administrator
*
*/
public class Factory {
        int[] arr = new int[1];//生产者生产的物品放入该数组中，消费者从该数组中取值
        int index = 0;//记录生产者生产一个，或消费者消费一个
        //1.生产东西
        public synchronized void setProduct(int num) {
            try {
                if(index==1) {//生产者已经生产，但是消费者未消费
                    this.wait(3000);
                }
            } catch (InterruptedException e) {
                    e.printStackTrace();
            }
            arr[0]=num;//生产的东西保存，以便消费者消费
            System.out.println("生产者生产:"+arr[0]);
            this.notify();//通知消费者消费
            index++;
        }
        //2.取东西
        public synchronized void getProduct() {
            try {
                if(index==0) {
                     this.wait();//如果发现index==0说明还未生产好，需要等待
                }
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
            
        System.out.println("消费者消费:"+arr[0]);
        index--;
        //this.notify();//通知生产者生产
        }
    }

public class Product extends Thread{
    Factory factory = null;
    public Product(Factory factory) {
        super();
        this.factory = factory;
    }
    
    @Override
    public void run() {
        for(int i=1;i<=10;i++) {
            factory.setProduct(i);
        }
    }
}

public class Customer extends Thread {
    Factory factory = null;
    public Customer(Factory factory) {
        super();
        this.factory = factory;
    }
    
    @Override
    public void run() {
        for(int i=1;i<=10;i++) {
            factory.getProduct();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Factory fa = new Factory();
        Product p = new Product(fa);
        p.start();
        Customer c = new Customer(fa);
        c.start();
    }
}

6、其他创建线程方式

1> 实现Callable接口

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNewTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2>线程池:

经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。如何解决？提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁的创建销毁，实现重复利用。使用线程池的好处：提高响应速度，减少了创建新线程的时间，奖励资源消耗，重复利用线程池中的线程，不需要每次都创建。便于线程管理。有一些属性：corePoolSize:核心池的大小，maxnumPoolSize:最大线程数，keeAliveTime:线程没有任务时最多保持多长时间会终止。

class NumberThread implements Runnable{
    
    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " +i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

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

public class ThreadPool {
    
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
        // System.out.println(service.getClass());
        // service1.setCorePoolSize(15);
        // service1.setKeepAliveTime();
        
        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable
        
        // service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

码农公寓