Java 多线程

Posted Hesier

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 多线程相关的知识,希望对你有一定的参考价值。

在Java中,一个应用程序对应着一个JVM实例(JVM进程),一般来说名字默认为java.exe或者javaw.exe(windows下可以通过任务管理器查看)。Java采用的是单线程编程模型,即在我们自己的程序中如果没有主动创建线程的话,只会创建一个线程,通常称为主线程。但是,虽然只有一个线程来执行任务,不代表JVM中只有一个线程,JVM实例在创建的时候,同时会创建很多其他的线程(比如垃圾收集器线程)。
一个进程包括多个线程,这些线程是共同享有进程占有的资源和地址空间的。进程是操作系统进行资源分配的基本单位,而线程是操作系统进行调度的基本单位。

一、线程创建

  • 创建线程类(继承Thread或实现Runnable接口)
  • 创建线程对象thread(如果通过实现Runnable创建线程类,则要需要将Runnable作为Thread类的参数)
  • 通过start方法启动
// 继承Thread
class MyThread extends Thread{
    private static int num = 0;
    public MyThread(){
        num++;
    }
    
    @Override
    public void run(){
        System.out.println("主动创建的第"+num+"个线程");
    }
}

public class Test{
    public static void main(String[] args){
        MyThread thread = new MyThread();
        thread.start();
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable{
    public MyRunnable(){}
    @Override
    public void run(){
        System.out.println("子线程ID:" + Thread.currentThread().getId());
    }
}

public class Test{
    public static void main(String[] args){
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

 

二、Thread 类

1、线程的状态

  创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡(dead)

 

  • 线程创建之后,不会立即进入就绪状态,因为线程的运行需要一些条件(比如内存资源:程序计数器、Java栈、本地方法栈都是线程私有的,所以需要为线程分配一定的内存空间),只有线程运行需要的所有条件满足了,才进入就绪状态。
  • 当线程进入就绪状态后,不代表立刻就能获取CPU执行时间,也许此时CPU正在执行其他的事情,因此它要等待。当得到CPU执行时间之后,线程便真正进入运行状态。
  • 线程在运行状态过程中,可能有多个原因导致当前线程不继续运行下去,比如用户主动让线程睡眠(睡眠一定的时间之后再重新执行)、用户主动让线程等待,或者被同步块给阻塞,此时就对应着多个状态:time waiting(睡眠或等待一定的事件)、waiting(等待被唤醒)、blocked(阻塞)。
  • 当由于突然中断或者子任务执行完毕,线程就会被消亡。

 线程间进行上下文切换的时候会记录程序计数器、CPU寄存器状态等数据。

 

 2、Thread类中常用方法:

  • start方法。start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。
  • run方法。run()方法是不需要用户来调用的,当通过start方法启动一个线程之后,当线程获得了CPU执行时间,便进入run方法体去执行具体的任务。即start()内部调用了run()方法。直接调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动。
  • sleep方法。sleep相当于让线程睡眠,交出CPU,让CPU去执行其他的任务。但是有,sleep方法不会释放锁,也就是说如果当前线程持有某个对象的锁,则即使调用sleep方法,其他线程也无法访问这个对象。如果调用了sleep方法,必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后,不一定会立即得到执行,因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态
  • yield方法。调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。注意,调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间。
  • join方法。假如在main线程中,调用thread.join方法,则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法,则等待thread执行完毕,如果调用的是指定了时间参数的join方法,则等待一定的时间。实际上调用join方法是调用了Object的wait方法,wait方法会让线程进入阻塞状态,并且会释放线程占有的锁,并交出CPU执行权限。
  • interrupt方法。调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常,也就说,它可以用来中断一个正处于阻塞状态的线程。但是直接调用interrupt方法不能中断正在运行中的线程。
  • 静态方法currentThread()用来获取当前线程。
  • setDaemon和isDaemon 用来设置线程是否成为守护线程和判断线程是否是守护线程。守护线程和用户线程的区别在于:守护线程依赖于创建它的线程,而用户线程则不依赖。举个简单的例子:如果在main线程中创建了一个守护线程,当main方法运行完毕之后,守护线程也会随着消亡。而用户线程则不会,用户线程会一直运行直到其运行完毕。在JVM中,像垃圾收集器线程就是守护线程。

  注意:wait,notify,notifyAll是属于Object。

  只能在同步方法或者同步块中使用wait()方法。在执行wait()方法后,当前线程释放锁(这点与sleep和yield方法不同)。调用了wait函数的线程会一直等待,直到有其他线程调用了同一个对象的notify或者notifyAll方法才能被唤醒,需要注意的是:被唤醒并不代表立刻获得对象的锁,要等待执行notify()方法的线程执行完,即退出synchronized代码块后,当前线程才会释放锁,而呈wait状态的线程才可以获取该对象锁。

  如果调用wait()方法时没有持有适当的锁,则抛出IllegalMonitorStateException,它是RuntimeException的一个子类,因此,不需要try-catch语句进行捕获异常。notify方法只会(随机)唤醒一个正在等待的线程,而notifyAll方法会唤醒所有正在等待的线程。如果一个对象之前没有调用wait方法,那么调用notify方法是没有任何影响的。 

  

 

三、synchronized

1.synchronized方法

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public void insert(Thread thread){
        for(int i=0; i<5; i++){
            System.out.println(thread.getName()+"insert number " + i);
            list.add(i);
        }
    }
}

public class Test{
    public static void main(String[] args){
        final InsertData insertData = new InsertData();
        new Thread(){
            public void run(){
                insertData.insert(Thread.currentThread());
            }
        }.start();
        
        new Thread(){
            public void run(){
                insertData.insert(Thread.currentThread());
            }
        }.start(); 
    }
}

 输出结果为:

给insert 方法加上synchronized 关键字

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public synchronized void insert(Thread thread){
        for(int i=0; i<5; i++){
            System.out.println(thread.getName()+"insert number " + i);
            list.add(i);
        }
    }
}

输出结果为:

  • 当一个线程正在访问一个对象的synchronized方法,那么其他线程不能访问该对象的其他synchronized方法。因为一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized方法。
  • 当一个线程正在访问一个对象的synchronized方法,那么其他线程能访问该对象的非synchronized方法。因为访问非synchronized方法不需要获得该对象的锁,假如一个方法没用synchronized关键字修饰,说明它不会使用到临界资源,那么其他线程是可以访问这个方法的。

 

2.synchronized代码块

synchronized(synObject){
    
}

synObject可以是this,代表获取当前对象的锁,也可以是类中的一个属性,代表获取该属性的锁。

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    public void insert(Thread thread){
        synchronized(this){
            for(int i=0; i<5; i++){
                System.out.println(thread.getName()+"insert number " + i);
                list.add(i);
            }
        }
    }
}

或者:

class InsertData{
    private ArrayList<Integer> list = new ArrayList<>();
    private Object object = new Object();
    
    public void insert(Thread thread){
        synchronized(object){
            for(int i=0; i<5; i++){
                System.out.println(thread.getName()+"insert number " + i);
                list.add(i);
            }
        }
    }
}

 总结就是:

  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程仍然可以访问“该对象”的非同步代码块
  • 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。

举例:

class MyRunnable implements Runnable{
    @Override
    public void run(){
        synchronized(this){
            try{
                for(int i=0; i<5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop "+i);
                }
            }catch (InterruptedException ie){
                
            }
        }
    }
}

public class Test{
    public static void main(String[] args){
        Runnable demo = new MyRunnable();
        Thread t1 = new Thread(demo, "t1");
        Thread t2 = new Thread(demo, "t2");
        t1.start();
        t2.start();
    }
}

 t1和t2都是基于"demo这个Runnable对象"创建的线程,我们可以将synchronized(this)中的this看作是“demo这个Runnable对象”。因此,线程t1和t2共享“demo对象的同步锁”。

 结果:

t1 loop 0
t1 loop 1
t1 loop 2
t1 loop 3
t1 loop 4
t2 loop 0
t2 loop 1
t2 loop 2
t2 loop 3
t2 loop 4

 

但是,如果

class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run(){
        synchronized(this){
            try{
                for(int i=0; i<5; i++){
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " loop "+i);
                }
            }catch (InterruptedException ie){
                
            }            
        }
    }
}

public class Test{
    public static void main(String[] args){
        Thread t1 = new MyThread("t1");
        Thread t2 = new MyThread("t2");
        t1.start();
        t2.start();
    }
}

 

t1和t2是两个不同的MyThread对象,因此t1和t2在执行synchronized(this)时,获取的是不同对象的同步锁。

结果:

t1 loop 0
t2 loop 0
t1 loop 1
t2 loop 1
t1 loop 2
t2 loop 2
t1 loop 3
t2 loop 3
t1 loop 4
t2 loop 4

 

 

3、全局锁

如果一个线程执行一个对象的非static synchronized方法,另外一个线程需要执行这个对象所属类的static synchronized方法,此时不会发生互斥现象,因为访问static synchronized方法占用的是类锁(全局锁),而访问非static synchronized方法占用的是对象锁,所以不存在互斥现象。

pulbic class Something {
    public synchronized void isSyncA(){}
    public synchronized void isSyncB(){}
    public static synchronized void cSyncA(){}
    public static synchronized void cSyncB(){}
}

假设,Something有两个实例x和y。分析下面4组表达式获取的锁的情况。

(01) x.isSyncA()与x.isSyncB() 
(02) x.isSyncA()与y.isSyncA()
(03) x.cSyncA()与y.cSyncB()
(04) x.isSyncA()与Something.cSyncA()

(01) 不能被同时访问。因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁!

(02) 可以同时被访问。因为访问的不是同一个对象的同步锁,x.isSyncA()访问的是x的同步锁,而y.isSyncA()访问的是y的同步锁。

(03) 不能被同时访问。因为cSyncA()和cSyncB()都是static类型,x.cSyncA()相当于Something.isSyncA(),y.cSyncB()相当于Something.isSyncB(),因此它们共用一个同步锁,不能被同时反问。

(04) 可以被同时访问。因为isSyncA()是实例方法,x.isSyncA()使用的是对象x的锁;而cSyncA()是静态方法,Something.cSyncA()可以理解对使用的是“类的锁”。因此,它们是可以被同时访问的。

 

注意:对于synchronized方法或者synchronized代码块,当出现异常时,JVM会自动释放当前线程占用的锁,因此不会由于异常导致出现死锁现象。

 

以上是关于Java 多线程的主要内容,如果未能解决你的问题,请参考以下文章

Java多线程与并发库高级应用-工具类介绍

多线程 Thread 线程同步 synchronized

Java多线程具体解释

自己开发的在线视频下载工具,基于Java多线程

什么是JAVA的多线程?

多个用户访问同一段代码