`
lxm63972012
  • 浏览: 36919 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

synchronized 实例

    博客分类:
  • java
阅读更多

synchronized  Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。

先看几个例子:

 

 实例一:

import java.util.ArrayList;
import java.util.List;

public class MyThread {
 public void printNum(List list) {
  synchronized (list) {
   if (null != list) {
    for (int i = 0; i < list.size(); i++) {
     System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }

 public static List getList() {
  List list = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list.add(i);
  }
  return list;
 }

 public static void main(String[] args) {
  final MyThread mt = new MyThread();
  final MyThread mt1 = new MyThread();
  final List list = mt.getList();
  
  Thread t1 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list);
   }
  }, "t1");
  
  Thread t2 = new Thread(new Runnable(){
   public void run() {
    mt1.printNum(list);
   }
  }, "t2");
  t1.start();
  t2.start();

 }

}

输出结果:

 t1:1
t1:2
t1:3
t1:4
t1:5
t2:1
t2:2
t2:3
t2:4
t2:5

 

 

实例二:

  import java.util.ArrayList;
import java.util.List;

public class MyThread {
 public void printNum(List list) {
  synchronized (list) {
   if (null != list) {
    for (int i = 0; i < list.size(); i++) {
     System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }

 public static List getList() {
  List list = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list.add(i);
  }
  return list;
 }
   
 public static void main(String[] args) {
  final MyThread mt = new MyThread();
  final MyThread mt1 = new MyThread();
  final List list = mt.getList();
  final List list1 = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list1.add(i);
  }
  Thread t1 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list);
   }
  }, "t1");
  
  Thread t2 = new Thread(new Runnable(){
   public void run() {
    mt1.printNum(list1);
   }
  }, "t2");
  t1.start();
  t2.start();

 }

}

 

输出结果:

t1:1
t2:1
t1:2
t2:2
t2:3
t1:3
t1:4
t2:4
t2:5
t1:5

 

 实例三:

 

  import java.util.ArrayList;
import java.util.List;

public class MyThread {
 public  void printNum(List list) {
  synchronized (this) {
   if (null != list) {
    for (int i = 0; i < list.size(); i++) {
     System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }

 public static List getList() {
  List list = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list.add(i);
  }
  return list;
 }
   
 public static void main(String[] args) {
  final MyThread mt = new MyThread();
  final MyThread mt1 = new MyThread();
  final List list = mt.getList();
  final List list1 = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list1.add(i);
  }
  Thread t1 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list);
   }
  }, "t1");
  
  Thread t2 = new Thread(new Runnable(){
   public void run() {
    mt1.printNum(list1);
   }
  }, "t2");
  t1.start();
  t2.start();

 }

}

 

输出结果:

 t1:1
t2:1
t1:2
t2:2
t1:3
t2:3
t1:4
t2:4
t1:5
t2:5

 

实例四:

  import java.util.ArrayList;
import java.util.List;

public class MyThread {
 public  void printNum(List list) {
  synchronized (this) {
   if (null != list) {
    for (int i = 0; i < list.size(); i++) {
     System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }

 public static List getList() {
  List list = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list.add(i);
  }
  return list;
 }
   
 public static void main(String[] args) {
  final MyThread mt = new MyThread();
  final MyThread mt1 = new MyThread();
  final List list = mt.getList();
  final List list1 = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list1.add(i);
  }
  Thread t1 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list);
   }
  }, "t1");
  
  Thread t2 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list1);
   }
  }, "t2");
  t1.start();
  t2.start();

 }

}

 

输出结果:

 t1:1
t1:2
t1:3
t1:4
t1:5
t2:1
t2:2
t2:3
t2:4
t2:5

 

实例五:

 public class MyThread {
 public  void printNum(List list) {
  synchronized (list) {
   if (null != list) {
    for (int i = 0; i < list.size(); i++) {
     System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
     try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   }
  }
 }

 public static List getList() {
  List list = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list.add(i);
  }
  return list;
 }
   
 public static void main(String[] args) {
  final MyThread mt = new MyThread();
  final MyThread mt1 = new MyThread();
  final List list = mt.getList();
  final List list1 = new ArrayList();
  for (int i = 1; i <= 5; i++) {
   list1.add(i);
  }
  Thread t1 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list);
   }
  }, "t1");
  
  Thread t2 = new Thread(new Runnable(){
   public void run() {
    mt.printNum(list1);
   }
  }, "t2");
  t1.start();
  t2.start();

 }

}

输出结果:

t1:1
t2:1
t1:2
t2:2
t2:3
t1:3
t1:4
t2:4
t2:5
t1:5

 

由以上实例可以得出,不同的线程调用的必须是同一个对象,并且该对象与synchronized 锁的对象是同一个类时,才能够保证在同一时刻最多只有一个线程执行该段代码。

分享到:
评论

相关推荐

    Android synchronized 测试案例

    在Android开发中,`synchronized`关键字是Java语言中用于实现线程同步的重要工具,它在多线程环境下确保了共享资源的安全访问。本测试案例深入探讨了`synchronized`的使用方法,包括同步单个对象、同步多个对象以及...

    synchronized用法大全实例

    本实例大全将全面解析`synchronized`的使用方式,包括同步方法、同步语句块、类锁和对象锁。 ### 1. 同步方法 同步方法是通过在方法声明前加上`synchronized`关键字实现的。这样,同一时间只有一个线程可以执行该...

    使用synchronized实现多线程同步[借鉴].pdf

    1. **synchronized实例方法**: 当一个方法被声明为`synchronized`时,这意味着该方法在同一时间只能被一个线程访问。如果两个线程试图访问同一个对象的`synchronized`实例方法,只有一个线程能够获取到该对象的锁...

    java Thread & synchronized & concurrent 线程、同步、并发

    在Java中,`synchronized`关键字有两种用法:修饰实例方法和修饰代码块。对于实例方法,整个方法体被视为同步区域;对于代码块,可以指定特定的监视器对象,只有获得该对象锁的线程才能进入。 例如: ```java ...

    synchronized枷锁实例

    对象锁是针对类的实例对象而言的,当一个线程访问某个对象的非静态 synchronized 方法或同步代码块时,会获取到该对象的锁。这种锁确保了同一时间只有一个线程能访问该对象的成员变量。例如: ```java public class...

    Java Synchronized的使用详解

    静态方法:一个线程获取了该对象的锁之后,其他线程来访问其他Synchronized实例方法时无法获取该对象的锁,就不能访问该对象的其他Synchronized实例方法。 同步方法块:使用Synchronized修饰代码块,可以确保线程...

    java里面synchronized用法.doc

    1. 对象实例范围:synchronized 关键字可以被用于对象实例的方法上,以防止多个线程同时访问同一个对象的 synchronized 方法。例如: ```java public class MyClass { public synchronized void myMethod() { // ....

    Java synchronized详细解读.docx

    当`synchronized`作用于实例方法时,它锁定的是调用该方法的对象实例,这意味着在同一时间,只有一个线程可以执行该对象上的同步方法。如果存在多个对象实例,即使它们的同步方法相同,不同实例的同步方法也可以同时...

    synchronized并发讲解源码.zip

    `synchronized`关键字主要有两种用法:修饰实例方法和同步代码块。当一个方法被`synchronized`修饰时,同一时间只能有一个线程访问该方法,其他试图访问的线程会被阻塞,直到当前线程执行完毕。这种方式保证了同一...

    Synchronized关键字的用法

    - **实例方法**:可以直接将`synchronized`关键字放在实例方法前,此时该方法的锁为当前对象实例本身。 ```java public synchronized void method() { // 同步方法体 } ``` - 当一个线程调用此方法时,会锁定...

    Java synchronized使用案例

    这里的`object`通常是共享资源的实例引用。 二、`synchronized`的作用 1. **线程互斥**:当一个线程在执行`synchronized`代码时,其他线程必须等待该线程释放锁后才能进入。 2. **内存可见性**:确保线程在读取或...

    synchronized详解

    `synchronized`关键字在Java编程语言中扮演着至关重要的角色,它是Java实现多线程同步的主要机制。通过使用`synchronized`,可以确保同一时间只有一个线程能够执行特定代码块,从而防止数据的不一致性和线程安全问题...

    synchronized的几种示例

    当在实例方法前使用`synchronized`关键字时,它会锁定当前对象的监视器,只有拥有该监视器的线程才能执行该方法。例如: ```java public class Counter { private int count = 0; public synchronized void ...

    Java 同步锁(synchronized)详解及实例

    在售票示例中,我们可以用`this`作为监视器对象,因为它代表当前类的实例: ```java public void run() { for (int i = 0; i ; i++) { if (this.ticket &gt; 0) { synchronized (this) { // 休眠1s try { ...

    java synchronized详解

    - **实例方法同步**:如果在类的方法前加上`synchronized`,那么该方法称为同步方法。每次只有一个线程能访问该方法,其他线程需要等待。 - **静态方法同步**:静态方法的同步是针对类级别的,这意味着所有线程都将...

    JAVA synchronized详解

    从输出结果可以看出,线程`t1`和`t2`分别执行了各自的循环,但它们是交替进行的,这是因为它们都尝试获取同一个对象(即`Thread2`实例)的锁。 #### 四、总结 `synchronized`关键字是Java中实现线程安全的重要手段...

    实例解析Java中的synchronized关键字与线程平安问题_.docx

    但是,很多开发者对 synchronized 关键字的理解并不够深入,本文将通过实例解析 Java 中的 synchronized 关键字与线程平安问题,帮助开发者更好地理解和使用 synchronized 关键字。 首先,需要清晰的是 ...

    Java多线程程序中synchronized修饰方法的使用实例

    本篇将深入探讨`synchronized`修饰方法在Java多线程程序中的使用实例。 1. **同步方法** 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。当一个方法被声明为同步时,意味着在同一时刻只有一个线程...

    synchronized 的理解

    当`synchronized`用于修饰实例方法时,其锁对象是当前对象的实例。这意味着在任意时刻,都只有一个线程可以访问该实例的所有`synchronized`方法,或者进入由`synchronized(this)`标记的代码块。对于静态方法,锁对象...

    java_synchronized详解

    - **解释**:线程`A`和线程`B`共享同一个`Thread1`实例`t1`,因此当线程`A`获取到`t1`的锁并执行`synchronized(this)`内的代码时,线程`B`将被阻塞,直到线程`A`释放锁。 2. **同步代码块与非同步代码块的访问** ...

Global site tag (gtag.js) - Google Analytics