设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

详解Java多线程编程中的线程同步方法

2016-7-29 15:34| 发布者: zhangjf| 查看: 681| 评论: 0

摘要: 1、多线程的同步： 1.1、同步机制： 在多线程中，可能有多个线程试图访问一个有限的资源，必须预防这种情况的发生。所以引入了同步机制：在线程使用一个资源时为其加锁，这样其他的线程便不能访问那个资源了，直到解 ...

1、多线程的同步：
1.1、同步机制：
在多线程中，可能有多个线程试图访问一个有限的资源，必须预防这种情况的发生。所以引入了同步机制：在线程使用一个资源时为其加锁，这样其他的线程便不能访问那个资源了，直到解锁后才可以访问。

1.2、共享成员变量的例子：
成员变量与局部变量：
成员变量：

如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作，这多个线程是共享一个成员变量的。

局部变量：

如果一个变量是局部变量，那么多个线程对同一个对象进行操作，每个线程都会有一个该局部变量的拷贝。他们之间的局部变量互不影响。

下面举例说明：
实现了Runnable的线程类：

  2. class MyThread3 implements Runnable{
  4. //两个线程操作同一个对象，共享成员变量
  5. //int i;
  6. @Override
  7. public void run() {
  8. //两个线程操作同一个对象，各自保存局部变量的拷贝
  9. int i = 0;
  10. while(i<100){
  11. System.out.println(i);
  12. i++;
  13. try {
  14. Thread.sleep(100);
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. }
  20. }
复制代码

在main方法中用两个线程操作同一个对象：

  2. public static void main(String[] args) {
  4. MyThread3 myThread = new MyThread3();
  5. //下面两个线程对同一个对象(Runnable的实现类对象)进行操作
  6. Thread thread = new Thread(myThread);
  7. Thread thread2 = new Thread(myThread);
  8. //各自保存局部变量的拷贝，互不影响，输出200个数字
  9. thread.start();
  10. thread2.start();
  11. }
复制代码

这里如果把i变成成员变量，则输出100个数字。

1.3、共享资源导致的读取错误
下面举个例子，两个线程共用一个Number对象，通过Number类的getNumber方法获取数据，读取数据并改写时，发现了重复读操作：

首先创建一个Number类：

  2. class Number{
  3. private int number = 10;
  4. public String getNumber(int i){
  5. if(number > 0){
  6. try {
  7. Thread.sleep(100);
  8. } catch (InterruptedException e) {
  9. e.printStackTrace();
  10. }
  11. number -= i;
  12. return "取出"+i+"成功，剩余数量："+number;
  13. }
  14. return "取出"+i+"失败，剩余数量："+number;
  15. }
  16. }
复制代码

线程类，在线程类中的私有属性包含了Number类的引用：

  2. class MyThread4 extends Thread{
  4. //两个线程操作同一个对象，共享成员变量
  5. Number number;
  6. public MyThread4(Number number){
  7. this.number = number;
  8. }
  9. @Override
  10. public void run() {
  11. System.out.println(number.getNumber(8));
  12. }
  13. }
复制代码

在main函数中创建两个线程类，包含了同一个Number类实例的引用：

  2. public static void main(String[] args) {
  4. Number number = new Number();
  5. //两个线程操作同一个对象，共享对象number的成员变量number
  6. MyThread4 myThread = new MyThread4(number);
  7. MyThread4 myThread2 = new MyThread4(number);
  8. myThread.start();
  9. myThread2.start();
  10. }
复制代码

这样，当第一个线程读取Number中的number变量时先保存下来再休眠0.1秒，然后第二个线程再读取number变量并保存，此时两个线程保存了同样的数字，在修改时，也就导致修改了同一个数字两次。

2、同步机制的实现：

在多线程并发编程中Synchronized一直是元老级角色，很多人都会称呼它为重量级锁，但是随着Java SE1.6对Synchronized进行了各种优化之后，有些情况下它并不那么重了”
Java中的每一个对象都可以作为锁。

对于同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前对象的Class对象。
对于同步方法块，锁是Synchonized括号里配置的对象。
当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。
2.1、使用synchronized关键字创建synchronized方法：
使用synchronized关键字，该关键字修饰的方法叫做同步方法。

Java中每个对象都有一个锁或者称为监视器，当访问某个对象的synchronized方法时，表示将该对象上锁，而不仅仅是为该方法上锁。

这样如果一个对象的synchronized方法被某个线程执行时，其他线程无法访问该对象的任何synchronized方法（但是可以调用其他非synchronized的方法）。直至该synchronized方法执行完。

静态的synchronized方法调用情况：
当调用一个对象的静态synchronized方法时，它锁定的并不是synchronized方法所在的对象，而是synchronized方法所在对象对应的Class对象。这样，其他线程就不能调用该类的其他静态synchronized方法了，但是可以调用非静态的synchronized方法。

结论：执行静态synchronized方法锁方法所在对象，执行非静态synchronized方法锁方法所在对象对应的Class对象。

下面是多线程调用静态的方法的例子，由于锁定了方法所在对象对应的Class对象，其他线程无法调用该方法所在对象其他的静态synchronized方法：

  2. /**
  3. * 定义一个类，包含了线程类需要调用的方法
  4. */
  5. class Compute1{
  6. //这时如果某个线程调用该方法，
  7. //将锁定synchronized方法所在对象对应的class对象，
  8. //而不是锁定synchronized方法所在对象
  9. public synchronized static void execute(){
  10. for(int i = 0; i<100; i++){
  11. try {
  12. Thread.sleep(100);
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. }
  16. System.out.println("compute1:execute1 " + i++);
  17. }
  18. }
  19. public synchronized static void execute2(){
  20. for(int i = 0; i<100; i++){
  21. try {
  22. Thread.sleep(100);
  23. } catch (InterruptedException e) {
  24. e.printStackTrace();
  25. }
  26. System.out.println("compute1:execute2 " + i++);
  27. }
  28. }
  29. }
复制代码

main方法中两个线程分别调用同一个对象的两个static synchronized方法：

  2. public static void main(String[] args) {
  3. Compute1 com = new Compute1();
  4. Thread thread1 = new Thread1(com);
  5. Thread thread2 = new Thread2(com);
  6. thread1.start();
  7. thread2.start();
  8. }
复制代码

一次只能调用一个静态方法，直到执行完成。

2.2、使用synchronized创建同步代码块：
通过使用synchronized同步代码块，锁定一个对象，该对象作为可执行的标志从而达到同步的效果：

  2. /**
  3. * 定义一个类，包含了线程类需要调用的方法
  4. */
  5. class Compute1{
  6. //通过同步代码块锁定object1对象进行锁定了其他同样的synchronized代码块
  7. private Object object1 = new Object();
  8. public void execute(){
  9. synchronized(object1){
  10. for(int i = 0; i<100; i++){
  11. try {
  12. Thread.sleep(100);
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. }
  16. System.out.println("compute1:execute1 " + i++);
  17. }
  18. }
  20. }
  21. public synchronized void execute2(){
  22. synchronized(object1){
  23. for(int i = 0; i<100; i++){
  24. try {
  25. Thread.sleep(100);
  26. } catch (InterruptedException e) {
  27. e.printStackTrace();
  28. }
  29. System.out.println("compute1:execute2 " + i++);
  30. }
  31. }
  32. }
  33. }
复制代码

如果想要使用synchronized同步代码块达到和使用synchronized方法同样的效果，可以锁定this引用：

  2. synchronized(this){
  3. …
  4. }
复制代码

2.3、synchronized方法和synchronized同步代码块的区别：
synchronized同步代码块只是锁定了该代码块，代码块外面的代码还是可以被访问的。

synchronized方法是粗粒度的并发控制，某一个时刻只能有一个线程执行该synchronized方法。

synchronized同步代码块是细粒度的并发控制，只会将块中的代码同步，代码块之外的代码可以被其他线程同时访问。

收藏 邀请
上一篇：java中struts2实现简单的文件上传与下载下一篇：举例讲解Java设计模式编程中Decorator装饰者模式的运用

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 16:31

Copyright 2015-2025 djqfx

返回顶部