JavaEE进阶知识学习----多线程JUC高级知识-1-多线程知识简述

多线程基础知识

1.概述程序,进程和线程

程序:是为了完成某一特定的功能或任务,用某种语言编写的一段静态代码。
进程:是程序的一次执行过程,它自身有产生,存在和消亡的生命周期。
线程:是进程的小单元,是一个程序内部的一条执行路径。

2.Java中多线程的创建和使用

2.1线程的创建方法之一:继承Thread类,重写Run()方法。

使用说明:
1.定义子类继承Thread类。
2.子类中重写Thread类中的run方法。
3.创建Thread子类对象,即创建了线程对象
4.调用线程对象的start方法,启动线程,调用run方法。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.start();
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

Thread类常用方法说明

1.start(),启动线程并执行相应的run()方法。
2.run(),子线程要执行的代码放在run()方法中。
3.currentThread(),静态方法,调取当前的线程。
4.getName(),获取此线程的名字。
5.setName(),设置此线程的名字。
6.yield(),调用此方法的线程释放当前cpu的执行权。
以上方法的测试代码如下:

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i % 10 == 0){
                Thread.currentThread().yield();
            }
            
        }
    }
}

7.join(),在A线程中调用B线程的join()方法,表示A线程执行到此方法,A线程停止执行,直到B线程执行结束,在执行A线程剩余的。
8.isAlive(),判断线程是否还存活。
9.sleep(long long),显示的让当前线程睡眠long毫秒。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }   
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i == 20){
                try {
                    st.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(st.isAlive());
    }
}

10.线程通信:wait(),notify(),notifyAll()
11.getPriority(),返回线程的优先值。
12.setPriority(int newPriority),改变线程的优先级。

继承方式实例

模拟火车站售票窗口,开启三个窗口售票,总票数为100张

class Window extends Thread{
    static int ticket = 100;
    
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        
        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");
        
        w1.start();
        w2.start();
        w3.start();
    }
}

注意:ticket只有声明为static,因为三个线程是三个对象,如果不声明为static,三个线程对象就会各自拥有一个ticket=100,使用static修饰后,三个对象共用一个ticket=100。

2.1线程的创建方法之二:实现Runnable接口

1.定义子类,实现Runnable接口。
2.子类重写Runnable接口中的run方法。
3.通过Thread类含参构造器创建线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
5.调用Thread类的start方法,开启线程并调用Runnable子类的run方法。

class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for(int i = 1 ; i <= 100; i++){
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        t1.start();
        Thread t2 = new Thread(ra);
        t2.start();
    }
}

实现方式实例

class RunnableDemo implements Runnable{
    int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);
        
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

继承方法和实现方法的联系和区别

区别:
继承:线程代码存放在Thread子类的run方法中。
实现:线程代码存放在接口的子类的run方法中。
实现的好处:
1.避免了单继承的局限性
2.多个线程可以共享同一个接口的实现类的对象,适合多个线程来处理同一份资源。

3.线程的调度

3.1调度策略

时间片:就是按时间顺序,先到先执行。
抢占式:高高优先级的线程抢占CPU。

3.2Java中的调度方法

1.同优先级线程组成先进先出队列,使用时间片策略。
2.对高优先级,使用优先调度的抢占式策略。

3.3线程的优先级

MAX_PRIORITY(10); 最大的优先级
MIN _PRIORITY (1); 最小的优先级
NORM_PRIORITY (5); 默认的优先级
getPriority(),返回线程的优先值。
setPriority(int newPriority),改变线程的优先级。
线程的创建时继承父线程的优先级。
优先级别只是说线程抢占CPU的概率增加,并不能说是一定高优先级的先执行完。

4.线程的生命周期

JDK中用Thread.State枚举表示线程的几种状态。
1.新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
2.就绪:处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件
3.运行:当就绪的线程被调度并获得处理器资源时,便进入运行状态, run()方法定义了线程的操作和功能
4.阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出 CPU 并临时中止自己的执行,进入阻塞状态
5.死亡:线程完成了它的全部工作或线程被提前强制性地中止

image

5.线程的同步机制

在上面使用继承和实现方法的案例中,有时运行会出现一种情况重票,和负票的情况。这个就是线程安全问题。

线程安全问题原因:

我们创建了多个线程,存在共享数据,那就有可能出现线程安全问题,当其中一个线程操作共享数据时,还未操作完成 ,另外的线程参与进来,导致对共享数据的操作出现问题。

解决方法

要求一个线程操作共享数据结束后,其他线程才能参与进来。

方式一:同步代码块

synchronized(同步监视器){
    //需要被同步的代码块(即为操作共享数据的代码)
}

共享数据:多个线程共同操作的同一数据(变量)。
同步监视器:由一个类的对象来充当,那个线程获取此监视器,谁就执行大括号里面被同步的代码。俗称锁,任何一个类的对象都可以充当锁,要想保证线程的安全,就必须要求所有的线程共用一把锁。(如果将锁放在run方法里,就成了局部变量,就不会保证线程安全)
使用实现的方式中,同步监视器可以使用this,继承的的方式慎用this。

class RunnableDemo implements Runnable{
    int ticket = 100;//共享数据
    @Override
    public void run() {
        while(true){
            synchronized(this){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket--);
                }
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);
        
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

在继承方式中,锁只有声明为static才能保证线程安全,

方式二:同步方法

将操作共享数据的方法声明为synchronized,即表明此方法为同步方法。

class RunnableDemo implements Runnable{
    int ticket = 100;//共享数据
    @Override
    public void run() {
        while(true){
            show();
        }
    }
    public synchronized void show(){
        if(ticket > 0){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+ticket--);
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);
        
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
        
        t1.start();
        t2.start();
        t3.start();
    }
}

同步方法的锁:就时当前对象this。在继承方式中不能使用,因为锁代表当前对象。继承的方式有多个对象。

互斥锁

在Java语言中,为了保证共享数据操作的完整性,引入了对象互斥锁的概念。
每一个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只有一个线程访问改对象。
关键字synchronized来与对象的互斥锁联系,当某一个对象用synchronized修饰时,表明改对象在任一时刻只能由一个线程访问。
同步的局限性会导致程序的执行效率降低。

6.线程的通信

7.使用多线程的优点

1.提高应用程序的响应,增强用户体验。
2.提高计算机系统的CPU利用率。
3.改善程序结构,将既长又复杂的进程分为多个线程,独立运行,利于修改和理解。

你可能感兴趣的:(JavaEE进阶知识学习----多线程JUC高级知识-1-多线程知识简述)