您现在的位置:首页 >> 基础 >> Java编程 >> 内容

JAVA的多线程与高并发(一)、线程与同步锁

时间:2020-9-21 14:01:56

  核心提示:多线程与高并发写下本系列文章,用以记录学习多线程与高并发的过程。一些比较基础的知识会直接带过,不做详细说明。线程下面会从介绍线程到实现java多线程来讲。线程的概念线程的概念在我之前写的《Java开发...

多线程与高并发

写下本系列文章,用以记录学习多线程与高并发的过程。

一些比较基础的知识会直接带过,不做详细说明。

线程

下面会从介绍线程到实现java多线程来讲。

线程的概念

线程的概念在我之前写的《Java开发者需要了解的硬件知识 (二)、操作系统篇》中已经讲述过了。搬过来用一用。

进程是OS分配资源的基本单位,线程是执行调度的基本单位。

进程最重要的分配资源是:独立的内存空间。

线程调度执行(线程共享进程的内存空间,没有自己独立的内存空间)

线程在Linux中的实现

线程在Linux就是一个普通的进程,只不过和其他进程共享资源(内存空间,全局数据等。。。)

在JVM中的线程

创建一个JVM中线程,即申请一个操作系统的线程(重量级线程),1:1关系

JAVA中的线程

创建线程的两种方式

public class createThred {
    static class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("Thread1");
        }
    }

    static class Runnable1 implements Runnable {
        public void run() {
            System.out.println("Thread2");
        }
    }
    
    public static void main(String[] args) {
        // 第一种:写一个类继承Thread类,重写它的run方法
        Thread1 thread1 = new Thread1();
        thread1.start();
        // 第二种:写一个类实现Runnable接口,然后使用新类作为参数来创建新线程
        Thread thread2 = new Thread(new Runnable1());
        thread2.start();
        // 第二种的拓展,在Jdk8后使用lambda表达式
        Thread thread3 = new Thread(() ->  System.out.println("Thread3"));
        thread3.start();
    }
    
}

创建线程有两种方式,启动线程上有三种方式。

前两种就是创建线程的那两种,第三种启动线程的方式是在线程池中创建线程(使用Executors.newCachedThread,实际上内部还是前两种来实现的)

线程的状态

JAVA中线程的状态可以主要分成6种

  1. 新生状态(NEW):线程刚被创建出来,还未调用start()方法
  2. 可运行状态(RUNNABLE):处于该状态的线程随时可以被操作系统调度执行,它还可以根据线程工作情况细分为①就绪状态Ready②正在执行状态Running。
  3. 阻塞状态(BLOCKED):线程进入同步代码块前,需要获取锁,而在等待获取锁时,线程就会进入阻塞状态,获得锁后则进入就绪状态。
  4. 等待状态(WAITING):等待状态的线程都在等待另一个线程的特定操作(以解除它的等待状态),等待状态结束回到就绪状态。
  5. 超时等待状态(TIMED_WAITING):线程在等待另一个线程的特定操作后的指定时间内,会处于超时等待状态,直至操作完成并等待足够的时间后线程会被自动唤醒,并回到就绪状态
  6. 终结状态(TERMINATED):线程完成了他的执行方法后即进入终结状态,而且终结状态的线程无法再start()。
		/**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called {@code Object.wait()}
         * on an object is waiting for another thread to call
         * {@code Object.notify()} or {@code Object.notifyAll()} on
         * that object. A thread that has called {@code Thread.join()}
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;

线程的基本方法

1、sleep(long millis)

使线程睡眠millis毫秒,线程进入时间等待状态(TIMED_WAITING),睡眠完后线程回到就绪状态。

2、yeild()

使当前线程进入等待队列(就绪状态),等待操作系统下一次调度。

3、join()

在T1线程中调用T2的join()方法时,T1线程则会等待T2线程结束才进入等待队列(就绪状态)。(调用自己线程的join方法是没有意义的)

4、isAlive()

判断线程是否活动,返回boolean,在调用start()后与线程死亡前都是活动状态。

5、getPriority() / setPriority(int newPriority)

获取线程优先级与设置线程优先级,下图为线程优先级参考表,一般为5,**优先级高并不一定会优先执行,只是优先执行的概率更高。**

6、interrupt()

中断线程,interrupt() 并不能真正的中断线程,这点要谨记。需要被调用的线程自己进行配合才行。也就是说,一个线程如果有被中断的需求,那么就需要这样做:

1. 在正常运行任务时,经常检查本线程的中断标志位,如果被设置了中断标志就自行停止线程。
2. 在调用阻塞方法时正确处理InterruptedException异常。(例如:catch异常后就结束线程。)

7、wait() -- 来自Object方法

某个对象调用wait方法,会让当前线程进入等待状态,需要注意的是,这个wait()方法会释放线程持有的锁,意味着进入等待状态后,别的线程就有机会获得该线程释放出来的锁了。

8、notify() / notifyAll() -- 来自Object方法

某对象调用notify()方法,随机唤醒一个wait线程,让其进入就绪状态。
某对象调用notifyAll()方法,唤醒全部wait线程,让其进入就绪状态。

这部分牵扯到对象锁池的知识,可以参考 https://blog.csdn.net/djzhao/article/details/79410229

图解线程

同步锁Synchronized

本篇只是简要说明synchronized关键字的一些使用场景和使用细节。

在下一篇中,会详细的分析synchronized锁的实现和它的内部原理。

synchronized的锁定对象

1、指定对象

你可以指定一个对象,使用synchronized关键字来加锁

public class T {
	private int count = 10;
	private Object o  = new Object();

	public void m() {
        // 你也可以指定this对象
        // synchronized (this)
	synchronized (o) 
              {		
                  count--;
              }
	}
}

2、修饰方法

也可以直接在方法属性中使用synchronized,如此一来,会默认把调用该方法的对象作为锁(也就是this)

public class T {
	private int count = 10;

	public synchronized void m() {
        // 此时与上面第一种锁定this对象的效果是一样的
        count--;
	}
}

3、修饰静态方法

使用静态方法是不需要对象的,如果synchronized修饰静态方法,那么锁定的对象将是T.class,类的对象

public class T {
	private int count = 10;

	public synchronized static void m() {
        // 此时与上面第一种锁定this对象的效果是一样的
        count--;
	}
}

可重入性

如果在同一个线程中,对于一个对象,允许同步方法A的代码块中调用同步方法B。(前提是处于一个类中,锁的是同一个对象)

比如下面这块代码

public class T {
	synchronized void m1 () {
		System.out.println("m1");
		m2();
	}
	
	synchronized void m2 () {
		System.out.println("m1");
	}
}

synchronized必须是可重入锁,因为java中A继承B,A重写B的方法时的super.m()是可以正常执行的(无论这个方法是不是加了synchronized)。如果不是可重入的,那么这样的默认继承重写就没办法实现。

异常

如果在程序执行中抛出异常,那么锁会被释放。可能会因此产生不可预知的结果。

如果不想释放锁,可以主动catch产生的异常。

锁升级

synchronized在JDK早期,使用时会向操作系统申请重量级锁。在随后的升级版本中,加入了锁升级的概念。

意味着,synchronized不再是直接向操作系统申请重量级锁,而是一步步升级为重量级锁。

其中的过程有:

1、偏向锁

当没有任何竞争时(单线程执行synchronized代码时)

2、自旋锁

少量线程竞争

3、系统锁

大量线程竞争

Java免费学习   Java自学网 http://www.javalearns.com

关注微信号:javalearns   随时随地学Java

或扫一扫

随时随地学Java

作者:不详 来源:网络
    你是从哪里知道本网站的?
  • 网友介绍的
  • 百度搜索的
  • Google搜索的
  • 其它搜索过来的
  • 网址输错了进来的
  • 太忙了不记得了
共有评论 0相关评论
发表我的评论
  • 大名:
  • 内容:
  • java学习网(www.javalearns.com) © 2014 版权所有 All Rights Reserved.
  • Email:javalearns@163.com 站长QQ:1356121699 晋ICP备14003680号-3
  • java学习网部分内容来自网络或网友发布,如侵犯了您利益,请发邮件至:javalearns@126.com,我们尽快处理!
  • Java学习网
  • 网站统计
  • 晋公网安备 14042902000001号