说明:

1、个人技术也不咋滴、也没在项目中写过线程,以下全是根据自己的理解写的。所以,仅供参考及希望指出不同的观点。

2、其实想把代码的github贴出来,但还是推荐在初学的您多亲自写一下,就没贴出来了。

一、基本说明

类、对象:。。。(不知道怎么说,只可意会不可言传>.<!);要明白哪些方法、变量是对象的,哪些是类的。

类锁、对象锁:对应类和对象。每个类有且仅有一个类锁,每个对象有且仅有一个对象锁。

ex: Person p1 = new Person(); Person p2 = new Person();

Person类只有一个类锁,p1对象有自己的对象锁,p2也有自己的对象锁。所以,demo中一共有3把锁:1把类锁、2把对象锁。

进程、线程:一个进程可以有多个线程。

并发:最大化利用资源,轮流执行。ex: 只有一本《Think In Java》,A看一会B看一会。

并行:真正的同时进行,ex:有多本《Think In Java》,A看一本,B看一本。

摘自baike:

并发的实质是一个物理CPU(也可以多个物理CPU)在若干道程序之间多路复用,并发性是对有限物理资源强制行驶多用户共享以提高效率。

并行指的是两个或两个以上的事件或活动在同一时刻发生。在多道程序环境下,并行性使多个程序同一时刻可在不同CPU上同时执行。

我所知道的,java中的线程、或者平常说的线程基本都是并发的(我也不能确定,因为不清楚;前面baidu了下,基本博客说的java实现并行其实都是并发,但也看见有说JDK8能并行编程的,待了解)。

二、场景构想

场景:(不考虑线程安全,已知约束每次输出0~4)

要输出0、1、2、3、4共3次,即总共输出15次。

实现:

1、(类锁)3个对象各自执行1次。

2、(对象锁)一个对象执行3次。

三、实现1:3个对象各执行1次

1、现在不考虑线程安全、不考虑同步异步,只简单的满足:3个对象各自执行1次。

  1. public class ClassLock {
  2. public static void main(String[] args) {
  3. Runnable async = new AsyncClass();
  4. Thread t1 = new Thread(async,"Thread-A");
  5. Thread t2 = new Thread(async,"Thread-B");
  6. Thread t3 = new Thread(async,"Thread-C");
  7. t1.start(); // code-1
  8. t2.start(); // code-2
  9. t3.start(); // code-3
  10. }
  11. }
  12. /** 相对的异步 */
  13. class AsyncClass implements Runnable{
  14. @Override
  15. public void run() {
  16. for (int i = 0; i < 5; i++) {
  17. try {
  18. // Thread.sleep(1*1000);
  19. System.out.println(Thread.currentThread().getName() + " : " + i);
  20. } catch (Exception e) {
  21. e.printStackTrace();
  22. }
  23. }
  24. }
  25. }

特别重要说明:

1、java的线程调度是随机的,什么意思?

在上面代码中,只能保证t1、t2、t3都执行,但并不能确定输出的顺序。以下例举几个:

(个人理解,可能理解/用词错误)java代码还是按顺序执行,所以可以保证t1、t2、t3进入线程池(用词不好,或者说类似是进入候车厅,等待获取锁)的顺序是按代码顺序。但是,获取锁是随机(JVM决定)。

参考代码来说,进程Process-A开启线程Thread-main来执行main方法。此时只有一个线程:Thread-main。

当执行到code-1时开启了线程Thread-A,此时Process-A就有2个线程:Thread-main、Thread-A。

因为存在多个线程,所以现在Process-A就存在线程调度的问题。即,现在可能是继续执行main后面的代码,也可能去执行Thread-A的代码。或者轮换执行,即并发。

后面对应的,执行到code-2就有3个线程:Thread-main、Thread-A、Thread-B。

  1. public static void main(String[] args) {
  2. Runnable async = new AsyncClass();
  3. Thread t1 = new Thread(async,"Thread-A");
  4. Thread t2 = new Thread(async,"Thread-B");
  5. Thread t3 = new Thread(async,"Thread-C");
  6. System.out.println("vergilyn");
  7. t1.start();
  8. System.out.println("dante");
  9. t2.start();
  10. System.out.println("vergil");
  11. t3.start();
  12. System.out.println("end");
  13. }

上面代码的结果: 只能保证“vergilyn”是最先输出的,后面的输出顺序都不确定(包括end)。

2、(同步类锁)现在保证某个对象输出完了,另外一个对象才接着输出

因为是3个对象各自执行,所以要用类锁去控制,而不是对象锁。(同步静态方法加即等同于类锁)

  1. /** 同步 */
  2. class SyncClass implements Runnable{
  3. @Override
  4. public void run() {
  5. synchronized (SyncClass.class){ //sync-1
  6. for (int i = 0; i < 5; i++) {
  7. //synchronized (SyncClass.class) { //sync-2
  8. try {
  9. // Thread.sleep(1*1000);
  10. System.out.println(Thread.currentThread().getName() + " : " + i);
  11. } catch (Exception e) {
  12. e.printStackTrace();
  13. }
  14. // }
  15. }
  16. }
  17. }
  18. }

说明:因为是类锁,所以保证了每个对象进来,必须执行完for循环才释放类锁(当然也可以手动释放wait():释放了锁,其它线程可以去竞争获取该锁;sleep():未释放锁,锁的所有权还是在当前线程)

1、sync-1才能达到需求。保证了执行完for循环才释放锁。

2、sync-2当执行完try-catch就释放了锁,线程间又竞争获取该锁,并不能确定下一个获得锁的是哪个线程。

在多线程中,重要的一点就是:同步块的抉择(哪里才是最小同步块,或者这同步块对不对)、同步影响并发性。

在上面demo中其实举例不好,要达到需求只能写在sync-1,而不能写在sync-2。但这想说明的是,你要明确要锁的是什么,是对象、还是类。最小同步代码块在哪?

四、实现2:一个对象执行3次
  1. public class ObjectLock {
  2. public static void main(String[] args) {
  3. Runnable p1 = new SyncObject();
  4. // Runnable p1 = new AsyncThread();
  5. Thread t1 = new Thread(p1,"A");
  6. Thread t2 = new Thread(p1,"B");
  7. Thread t3 = new Thread(p1,"C");
  8. t1.start();
  9. t2.start();
  10. t3.start();
  11. }
  12. }
  13. class AsyncObject implements Runnable{
  14. @Override
  15. public void run() {
  16. for (int i = 0; i < 5; i++) {
  17. try {
  18. // Thread.sleep(1*1000);
  19. System.out.println(Thread.currentThread().getName() + " : " + i);
  20. } catch (Exception e) {
  21. e.printStackTrace();
  22. }
  23. }
  24. }
  25. }
  26.  
  27. class SyncObject implements Runnable{
  28. @Override
  29. public void run() {
  30. synchronized (this){
  31. for (int i = 0; i < 5; i++) {
  32. try {
  33. // Thread.sleep(1*1000); System.out.println(Thread.currentThread().getName() + " : " + i); } catch (Exception e) {
  34. e.printStackTrace();
  35. }
  36. }
  37. }
  38. }
  39. }

在demo中,其实和类锁的代码区别很少。无非是三个对象各自绑定一个线程执行,还是一个对象绑定三个线程执行(用词不好)

五、对象锁、类锁

不知道怎么用语言表达;希望通过上面代码能悟出什么是锁,什么是对象锁、类锁。

锁的作用,就是持有锁的线程才可以执行,别的线程只能等待获取锁。(再次说明:jvm随机决定谁能获取到锁。)

扩展:

持有锁的线程会释放锁:

1. 执行完同步代码块。

2. 在执行同步代码块的过程中,遇到异常而导致线程终止。

3. 在执行同步代码块的过程中,执行了锁所属对象的wait()方法,这个线程会释放锁,进入对象的等待池。

除了以上情况外,只要持有锁的线程还没有执行完同步代码块,就不会释放锁。

线程不会释放锁:

1.在执行同步代码块的过程中,执行了Thread.sleep()方法,当前线程放弃CPU,开始睡眠,在睡眠中不会释放锁。

2. 在执行同步代码块的过程中,执行了Thread.yield()方法,当前线程放弃CPU,但不会释放锁。

3.在执行同步代码块的过程中,其他线程执行了当前对象的suspend()方法,当前线程被暂停,但不会释放锁。但Thread类的suspend()方法已经被废弃。

六、线程安全

摘自baike:

线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

比如一个 ArrayList 类,在添加一个元素的时候,它可能会有两步来完成:1. 在 Items[Size] 的位置存放此元素;2. 增大 Size 的值。

在单线程运行的情况下,如果 Size = 0,添加一个元素后,此元素在位置 0,而且 Size=1;

而如果是在多线程情况下,比如有两个线程,线程 A 先将元素1存放在位置 0。但是此时 CPU 调度线程A暂停,线程 B 得到运行的机会。线程B向此 ArrayList 添加元素2,因为此时 Size 仍然等于 0 (注意,我们假设的是添加一个元素是要两个步骤,而线程A仅仅完成了步骤1),所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行,都增加 Size 的值,结果Size等于2。

那好,我们来看看 ArrayList 的情况,期望的元素应该有2个,而实际只有一个元素,造成丢失元素,而且Size 等于 2。这就是“线程不安全”了。

总的来说,要先明白变量、方法是属于类的还是对象的,或者还是局部变量。然后那些在线程间允许共享、哪些不允许。

(我所知道的)java的线程安全基本都是靠同步代码块来实现的。

1、线程不安全

线程间的数据不可预测,例如线程A把成员变量从1修改成2,但线程2读取到的可能是1。(并发性)

  1. public class ThreadSecurity {
  2. public static void main(String[] args) {
  3. Runnable r1 = new Insecurity();
  4. Thread t1 = new Thread(r1,"Thread-A");
  5. Thread t2 = new Thread(r1,"Thread-B");
  6. Thread t3 = new Thread(r1,"Thread-C");
  7. t1.start();
  8. t2.start();
  9. t3.start();
  10. }
  11. }
  12. /** 线程不安全 */
  13. class Insecurity implements Runnable{
  14. private int i = 5;
  15. @Override
  16. public void run() {
  17. try {
  18. if(i == 5){
  19. Thread.sleep(2);// 设置小点,才能看出来
  20. i -- ;
  21. System.out.println(Thread.currentThread().getName() + ":i=5");
  22. }
  23. } catch (InterruptedException e) {
  24. e.printStackTrace();
  25. }
  26.  
  27. }
  28. }

以上的输出结果:

因为不是线程安全的,所以在线程Thread-A、Thread-B、Thread-C执行的时候都可能:i==5。即可能Thread-A在判断完if后,就把锁交给Thread-B了,此时Thread-B的if还是true。(这正好说明了线程间的并发,轮换执行。宏观上看着是一起执行的,因为轮换调度时间很短)

2、线程安全

  1. /** 线程安全 */
  2. class Security implements Runnable{
  3. private int i = 5;
  4. @Override
  5. public void run() {
  6. try {
  7. synchronized (this){
  8. if(i == 5){
  9. Thread.sleep(2);
  10. i -- ;
  11. System.out.println(Thread.currentThread().getName() + ":i=5");
  12. }
  13. }
  14.  
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }
  18.  
  19. }
  20. }

以上demo,必定只会输出1次。

七、阻塞、死锁

阻塞:线程A得到锁,线程B、C在等待。则对线程B、C是阻塞的。

死锁:所有线程都在等待其它线程释放锁。(我在写oracle触发器的时候遇到过,事务A在等待事务B提交,事务B也在等待事务A提交。)

八、参考(以下是当初学习整理的博客文章,我也没认真看完,都是慢慢理解一点)

Java线程:概念与原理

Java多线程释放锁

Java 线程讲解 - 系列

ps: 周末沉迷手游无法自拔,有几篇想总结的一直没写…而且,本来以为这篇会写很多,但回头一看,还是不知道自己写了些什么。哪来这么多时间年让我慢慢来了?

手头项目要炸了,事前没有需求调查分析、需求转开发设计,有3张核心表都是1对1对1的,现在需求改要改成1对多、1对多。而且公司领导来一句2-3天能改好不,我就呵呵了。

而且、而且、而且,这项目负责人居然被公司领导调到别的项目组了。我这项目加上我才3个人,还是3个新人,2个代码1个运维。

本汪的内心不是崩溃的,早就被这些公司折磨碎了,心好累…好想回到农村,当一只骄傲的中华田园犬!

【Thread】java线程之对象锁、类锁、线程安全的更多相关文章

  1. (转)java 多线程 对象锁&类锁

    转自:http://blog.csdn.net/u013142781/article/details/51697672 最近工作有用到一些多线程的东西,之前吧,有用到synchronized同步块,不 ...

  2. 关于Java中的对象、类、抽象类、接口、继承之间的联系

    关于Java中的对象.类.抽象类.接口.继承之间的联系: 导读: 寒假学习JavaSE基础,其中的概念属实比较多,关联性也比较大,再次将相关的知识点复习一些,并理顺其中的关系. 正文: 举个例子:如果 ...

  3. 线程安全-002-多个线程多把锁&类锁

    一.多个对象多把锁 例子代码: package com.lhy.thread01; public class MultiThread { //static private int num = 0; / ...

  4. synchronized关键字以及实例锁 类锁

    Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this ...

  5. java双重检测或枚举类实现线程安全单例(懒汉模式)

    双重检测实现 /** * 懒汉模式->双重同步锁单例模式 */ public class SingletonExample5 { private SingletonExample5() { } ...

  6. Java并发编程-并发工具类及线程池

    JUC中提供了几个比较常用的并发工具类,比如CountDownLatch.CyclicBarrier.Semaphore. CountDownLatch: countdownlatch是一个同步工具类 ...

  7. 详解Java多线程编程中LockSupport类的线程阻塞用法

    LockSupport类是Java6(JSR166-JUC)引入的一个类,提供了基本的线程同步原语.LockSupport实际上是调用了Unsafe类里的函数,归结到Unsafe里,只有两个函数: p ...

  8. Java第二章----对象和类

    从第一章到第二章整整隔了一个月的时间,这速度也是慢的无语了.因为这个月负责开发公司一个SaaS类型APP,忙的昏天暗地终于上线了,这才有时间写个博客.本章还是以概念为主,有点枯燥重在理解. 第一节:对 ...

  9. java基础(二) -对象和类

    Java 对象和类 Java作为一种面向对象语言.支持以下基本概念: 多态 继承 封装 抽象 类 对象 实例 方法 重载 对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为.例如,一条狗是一 ...

  10. java中的对象、类、包、模块、组件、容器、框架、架构的概念入门

    在Java中有那么一些概念:对象.类.包.模块.组件.容器.框架.这些概念都有一个共同的特点,就是[容纳]. 对象(Object) 在Java的世界里,对象是通过属性和方法来分别对应事务所具有的静态属 ...

随机推荐

  1. Codeforces 1248C Ivan the Fool and the Probability Theory(推公式)

    题意 一个n*m的网格图,每个格子可以染黑色.白色,问你每个格子最多有一个相邻颜色相同的方案数 n,m<=1e5 思路 我们先处理\(1 \times m\)的情况 设\(f[i][j]\)为前 ...

  2. ELK:收集Docker容器日志

    简介 之前写过一篇博客 ELK:日志收集分析平台,介绍了在Centos7系统上部署配置使用ELK的方法,随着容器化时代的到来,容器化部署成为一种很方便的部署方式,收集容器日志也成为刚需.本篇文档从 容 ...

  3. Go语言实现:【剑指offer】复杂链表的复制

    该题目来源于牛客网<剑指offer>专题. 输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head.( ...

  4. 大话IDL之(基本操作流程)

    这里将对ENVI-IDL二次开发程序的一个通用流程做一个总结. 1.首先是文件打开和数据读取: 文件打开work_dir = dialog_pickfile(title='选择路径',/directo ...

  5. python学习(6)选择排序算法简单代码

    选择排序的基本思想是:每一趟在n-i+1(i=1,2,…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录.基于此思想的算法主要有简单选择排序.树型选择排序和堆排序.[1] 简单选择排序的基 ...

  6. java代码之美(16) ---Java8 Optional

    Java8 Optional 一句话介绍Optional类:使用JDK8的Optional类来防止NullPointerException(空指针异常)问题. 一.前言 在我们开放过程中,碰到的异常中 ...

  7. Coroutine 预激装饰器

    预激装饰器 讨论如何终止协程之前,我们要先谈谈如何启动协程.使用协程之前必须预激,可是这一 步容易忘记.为了避免忘记,可以在协程上使用一个特殊的装饰器.接下来介绍这样一个 装饰器. 预激协程的装饰器, ...

  8. objectarx 多段线自交检查

    只支持直线段的多段线检查,因为主要用了初中的知识,一元一次方程求交点,详细的说就是,把多段线上相邻的两个点构成一条直线段,然后每条直线段与剩余的直线段求交点,一条直线段就代表一个一元一次方程,知道两点 ...

  9. Angular目录结构

    一. Angular目录结构 e2e:在e2e/下是端到端测试 node_modules:安装的第三方模块都在这,使用npm install安装的1 Src:我们项目的所有文件 { App:组件,以a ...

  10. 风物长宜放眼量,人间正道是沧桑 - 一位北美 IT 技术人破局

    引言 我对于本科时光的印象,还停留在那所普通 211 大学的建筑物之间,我坐在大学的时光长廊里,满眼望去,都是经历的过的故事.可毕业后回首,却很少有人能说,自己从来没有迷茫过.迷茫,仿佛就是一团乌云, ...