jgs--多线程和synchronized

多线程

  多线程是我们开发人员经常提到的一个名词。为什么会有多线程的概念呢?我们的电脑有可能会有多个cpu(或者CPU有多个内核)这就产生了多个线程。对于单个CPU来说,由于CPU运算很快,我们在电脑上运行多个软件时,每个软件在CPU上运行很短的时间就会切换成其他软件。由于来回切换的时间很短,我们感觉好像所有的程序都在同时运行,这也是多线程。多线程可以解决较多的用户访问同一个服务时压力过大的问题,可以更充分的利用计算机的性能。

多线程的问题

  多线程的好处很多,可是相应的也出现了一些问题。其中最常见的就是脏读了。我们的程序,在多个线程访问同一个共享的数据,并且出现了对数据进行修改的时候,就很有可能出现脏读的情况。比如说:我有一个用户名为:yonghu,密码为:123的数据。我有两个线程,第一个线程将用户名密码修改为:yonghu1 : 456 第二个线程负责将修改后的数据读取。并且打印。这个时候,就有可能出现这样的输出:(用户名:yonghu 密码:456)的情况,这就是多线程并发带来的问题。代码如下:

    1 package jgs_11;
    2
    3 public class DirtyRead {
    4     private String username = "yonghu";
    5     private String password = "123";
    6
         // public synchronized void setValue(String username, String password) {
    7     public void setValue(String username, String password) {
    8         this.username = username;
    9         try {
   10             Thread.sleep(2000);
   11         } catch (Exception e) {
   12             e.printStackTrace();
   13         }
   14         this.password = password;
   15         System.out.println("setValue 最终结果:username =" + username + ", password = " + password);
   16     }
   17
   18     public synchronized void getValue() {
   19         System.out.println("getValue 最终结果:username =" + this.username + ", password = " + this.password);
   20     }
   21
   22     public static void main(String[] args) throws Exception {
   23         final DirtyRead dr = new DirtyRead();
   24         Thread t1 = new Thread(new Runnable() {
   25             @Override
   26             public void run() {
   27                 dr.setValue("yonghu1", "1654");
   28             }
   29         });
   30         t1.start();
   31         Thread.sleep(1000);
   32         dr.getValue();
   33     }
   34
   35 }

  出现这种情况的原因就是两个线程的方法,修改了同一个数据导致了资源在被修改的时候产生了我们不想要的结果。这就是脏读。

synchronized关键字

  那么,如何解决这个问题呢?我们可以给这个资源加一个锁,或者给调用这个资源的方法加一个锁。在一个线程对它进行修改的时候,将资源锁住,禁止其他线程访问。等这个线程操作完成后,才允许其他线程进行操作。这样做可以避免多个线程同时操作一个资源的时候出现问题的情况,但是会出现一个线程等待另外一个线程的情况。性能肯定会降低。这个锁的代码很简单,就是想锁住谁就给它前面加个synchronized关键字。然后就可以了,但是原理却是很复杂。

  大概是这样子的:其实synchronized的锁锁的都是对象。每个对象都有个类似于标记的东西,当我们执行一段代码,发现有synchronized关键字的时候,线程就去尝试获取这个关键字的锁(将这个标记修改下内容)。如果获取成功了(如果内容为标记值为0那么将值修改为1,表示获取锁成功,如果不为0表示当前锁处于被占用状态则获取锁失败),那么就执行代码。

  关于synchronized锁的原理,博主了解的也不是特别的透彻,希望各位大神多加指导。

时间: 2024-12-14 18:51:19

jgs--多线程和synchronized的相关文章

java 多线程8 : synchronized锁机制 之 方法锁

脏读 一个常见的概念.在多线程中,难免会出现在多个线程中对同一个对象的实例变量或者全局静态变量进行并发访问的情况,如果不做正确的同步处理,那么产生的后果就是"脏读",也就是取到的数据其实是被更改过的.注意这里 局部变量是不存在脏读的情况 多线程线程实例变量非线程安全 看一段代码: public class ThreadDomain13 { private int num = 0; public void addNum(String userName) { try { if ("

Java多线程-同步:synchronized 和线程通信:生产者消费者模式

大家伙周末愉快,小乐又来给大家献上技术大餐.上次是说到了Java多线程的创建和状态|乐字节,接下来,我们再来接着说Java多线程-同步:synchronized 和线程通信:生产者消费者模式. 一.同步:synchronized 多个线程同时访问一个对象,可能造成非线程安全,数据可能错误,所谓同步:就是控制多个线程同时访就是控制多线程操作同一个对象时,注意是同一个对象,数据的准确性, 确保数据安全,但是加入同步后因为需要等待,所以效率相对低下. 如:一个苹果,自己一个人去咬怎么都不会出问题,但是

四、java多线程核心技术——synchronized同步方法与synchronized同步快

一.synchronized同步方法 论:"线程安全"与"非线程安全"是多线程的经典问题.synchronized()方法就是解决非线程安全的. 1.方法内的变量为线程安全 public void addI(String username) { try { int num = 0; \\方法内的变量为线程安全 if (username.equals("a")) { num = 100; System.out.println("a set

Java多线程同步 synchronized 关键字的使用

代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B(或者C D等),有的话要等正在使用这个方法的线程B(或者C D)运行完这个方法后再运行此线程A,没有的话,直接运行它包括两种用法:synchronized 方法和 synchronized 块. JAVA多线程买票案例 synchronized 同步 用synchronized 块实现同步 public static void main(String[] args) { // runable对

Java多线程之~~~~synchronized 方法

在多线程开发中,总会遇到多个在不同线程中的方法操作同一个数据,这样在不同线程中操作这个数据不同的顺序 或者时机会导致各种不同的现象发生,以至于不能实现你预期的效果,不能实现一致性,这时候就可以使用 synchronized关键字对一个方法来说,这个synchronized能保证所有调用这个方法的线程只有一个正在操作这个方法, 不会出现同时多个线程进入这个方法的情况,下面我们来一个例子说明这个情况. 首先是一个Account类,这个类模拟账户,提供增加工资和减少工资的方法,当然,这个方法是被syn

多线程编程-- part 3 多线程同步->synchronized关键字

多线程同时访问一个资源,可以会产生不可预料的结果,所以为这个资源加锁,访问资源的第一个线程为其加锁后,其他线程便不能在使用那个资源,直到锁被解除. 举个例子: 存款1000元,能取出800的时候我就取800,当我同时用两个线程调用这个取钱操作时,有时可以取出1600元 static class HelloRunable implements Runnable{ private int money = 1000; //取出800元 int getMoney() { System.out.print

java 多线程9 : synchronized锁机制 之 代码块锁

synchronized同步代码块 用关键字synchronized声明方法在某些情况下是有弊端的,比如A线程调用同步方法执行一个较长时间的任务,那么B线程必须等待比较长的时间.这种情况下可以尝试使用synchronized同步语句块来解决问题.看一下例子: 下面例子是优化后的例子 使用代码块锁,原先例子是方法锁,就是同步 必须要执行2个for  public class ThreadDomain18 { public void doLongTimeTask() throws Exception

Java多线程:synchronized关键字和Lock

一.synchronized synchronized关键字可以用于声明方法,也可以用来声明代码块,下面分别看一下具体的场景(摘抄自<大型网站系统与Java中间件实践>) 案例一:其中foo1和foo2是SynchronizedDemo1类的两个静态方法.在不同的线程中,这两个方法的调用是互斥的,不仅是它们之间,任何两个不同线程的调用也互斥. public class SynchronizedDemo1 { public synchronized static void foo1(){} pu

Java多线程同步 – synchronized 用法

1.      利用类对象进行同步 当两个线程访问同一个类对象时,发生竞争.同步加锁的是对象,而不是代码. package thrds; public class FiveThread { public static void main(String args[]) { ThTst obj = new ThTst(); Thread t1 = new Thread(obj); // 两个线程用同一个对象,发生互斥(属于对象互斥) Thread t2 = new Thread(obj); t1.s

多线程与synchronized关键字

在写这篇文章之前我看过一些关于多线程同步的文章,从他们的文章中总结了很多精华,也发现一些不足.很多文章都是从以下四个方面来分析的. 1.synchronized修饰一个非静态函数,例如synchronized method() 2.synchronized修饰一个静态函数,例如static synchronized method() 3.synchronized修饰一个对象,例如synchronized(obj){} 4.synchronized修饰一个类,例如synchronized(Obje