java线程安全

最新推荐文章于 2023-04-28 11:53:22 发布
最新推荐文章于 2023-04-28 11:53:22 发布
阅读量267 收藏 1
点赞数 1
分类专栏： java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RainSpeech/article/details/48347191
版权

在网上看了好多文章大家不尽相同，所以，我想自己动手试一下，第一次写文章，大家多指教
第一种：synchronized方法

package com.fn.test.threadsafe;


public class Test {


    public synchronized void iteration(String name){
        for (int i = 0; i < 5; i++) {
            System.out.println(name+":"+i);
        }
    }

    public synchronized void iteration2(String name){
        for (int i = 0; i < 5; i++) {
            System.out.println(name+":"+i);
        }
    }
}

测试类

public class test_main {

    public static void main(String[] args) {
        //线程安全
        final Test test=new Test();
        Thread test1=new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                test.iteration("test1");
            }
        });
        Thread test2=new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                test.iteration2("test2");
            }
        });
        test1.start();
        test2.start();
    }

运行结果

test1:0
test1:1
test1:2
test1:3
test1:4
test2:0
test2:1
test2:2
test2:3
test2:4

上面的这个运行结果证明在一个实例方法上添加关键字synchronized 获得的是对象锁

第二种：synchronized（this）

package com.fn.test.threadsafe;

public class Test {

    public void iteration(String name){
        synchronized(this){
            for (int i = 0; i < 5; i++) {
                System.out.println(name+":"+i);
            }
        }
    }

    public void iteration2(String name){
        synchronized(this){
            for (int i = 0; i < 5; i++) {
                System.out.println(name+":"+i);
            }
        }
    }
}

运行结果

test1:0
test1:1
test1:2
test1:3
test1:4
test2:0
test2:1
test2:2
test2:3
test2:4

测试类代码同上
从运行结果中可以看到synchronized（this）获得也是对象锁

第三种：synchronized（obj）

package com.fn.test.threadsafe;

public class Test {

    private Integer num=0;
    private Integer sum=0;

    public void iteration(String name){
        synchronized(num){
            for (int i = 0; i < 5; i++) {
                num++;
                System.out.println(name+":"+num);
            }
        }
    }

    public void iteration2(String name){
        synchronized(sum){
            for (int i = 0; i < 5; i++) {
                sum--;
                System.out.println(name+":"+sum);
            }
        }
    }
}

运行结果

test2:-1
test2:-2
test2:-3
test2:-4
test2:-5
test1:1
test1:2
test1:3
test1:4
test1:5

synchronized(num)获得的是num这个对象的锁

第四种：volatile
这个关键字是无意中发现的，后来通过百度了解到这个关键字的作用是修饰一个对象，然后告诉java虚拟机，这个对象的值可能会被其它线程改变，所以每次使用该对象的时候就要重新获取，而不是使用寄存器中的值 

package com.fn.test.threadsafe;

public class Test {

    private volatile Integer num=0;
    private Integer sum=0;

    public void iteration(String name){
        for (int i = 0; i < 5; i++) {
            num++;
            System.out.println(name+":"+num);
        }
    }

    public void iteration2(String name){
        for (int i = 0; i < 5; i++) {
            num--;
            System.out.println(name+":"+num);
        }
    }

    public void showNum(){
        System.out.println("num="+num);
    }
}

测试类有所改变所以再发一次

package test;

import java.awt.Label;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import com.fn.test.genericity.Apple;
import com.fn.test.genericity.Fruit;
import com.fn.test.genericity.FujiApple;
import com.fn.test.threadsafe.Test;
import com.fn.test.threadsafe.UserAccount;

public class test_main {

    public static void main(String[] args) {
        //线程安全
        final Test test=new Test();
        Thread test1=new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                test.iteration("test1");
            }
        });
        Thread test2=new Thread(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                test.iteration2("test2");
            }
        });
        test1.start();
        test2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        test.showNum();
    }

运行结果1

test1:0
test2:0
test1:1
test2:0
test1:1
test2:0
test1:1
test2:0
test1:1
test2:0
num=0

运行结果2

test1:1
test2:1
test1:2
test2:1
test1:2
test2:1
test1:2
test2:1
test1:2
test2:1
num=1

两次的运行结果不一样，想必大家已经知道为什么了，因为在去重新获取的这一段时间，它的值被再次改变了，所以这个关键字并不能保证数据并发线程安全

第五种： Lock 

package com.fn.test.threadsafe;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {

    private Integer num=0;
    private Integer sum=0;

    Lock lock = new ReentrantLock(); 

    public void iteration(String name){
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                num++;
                System.out.println(name+":"+num);
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public void iteration2(String name){
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                num--;
                System.out.println(name+":"+num);
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }

    public void showNum(){
        System.out.println("num="+num);
    }
}

运行结果

test1:1
test1:2
test1:3
test1:4
test1:5
test2:4
test2:3
test2:2
test2:1
test2:0
num=0

通过运行结果可以看到是可以保证线程安全的，它的原理是每次lock（）的时候检查Lock对象是否已经上锁，如果已经上锁，那就等待解锁，负责就执行并上锁
第六种：ThreadLocal

package com.fn.test.threadsafe;


public class Test {

    private ThreadLocal<Integer> num=new ThreadLocal<Integer>(){
        protected Integer initialValue() {return 0;};
    };
    private Integer sum=0;

    public void iteration(String name){
        for (int i = 0; i < 5; i++) {
            num.set(num.get()+1);;
            System.out.println(name+":"+num.get());
        }
    }

    public void iteration2(String name){
        for (int i = 0; i < 2; i++) {
            num.set(num.get()-1);;
            System.out.println(name+":"+num.get());
        }
    }

    public void showNum(){
        System.out.println("num="+num.get());
    }
}

运行结果

test2:-1
test1:1
test2:-2
test1:2
test1:3
test1:4
test1:5
num=0

结果表明ThreadLocal只是为每个访问该对象的线程提供一个该对象的复制值版，所以当运行完成之后打印num的时候并没有改变num的值（包括主线程），常用于资源类对象，如数据库连接这种不需要同步，只需要解决线程安全问题的地方

RainSay
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全读写锁、File 类、I/O框架
liu1shi的博客
12-01 311
  ReentrantReadWriteLock 读写锁。一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁； 支持多次分配读锁，使多个读操作可以并发执行。   写-写：互斥，阻塞。读-写：互斥，读阻塞写、写阻塞读。读-读：不互斥、不阻塞。在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。 public class Lock1 { private int num; // Lock lock1 = new ReentrantLock(); ReentrantRea..
如何实现多个线程同时读取相同的inputstream_Spring中获取request的几种方法，及线程安全性...
weixin_32491255的博客
01-21 589
作者：编程迷思https://www.cnblogs.com/kismetv/p/8757260.htmlJava架构师做了编排概述在使用Spring MVC开发Web系统时，经常需要在处理请求时使用request对象，比如获取客户端ip地址、请求的url、header中的属性(如cookie、授权信息)、body中的数据等。由于在Spring MVC中，处理请求的Controller、Servi...
Java学习笔记（第五周）
Air_dreamer的博客
08-20 479
一、流 1.流概述： 流是一组有序的数据序列，根据操作的类型，可分为输入流和输出流两种。I/O（Input/Output）流提供了一条通道程序，可以使用这条通道把源中的字节序列送到目的地。虽然I/O流经常与磁盘文件存取有关，但是程序的源和目的地也可以是键盘、鼠标、内存或显示器窗口等。 2.输入输出流： ①输入流： InputStream类是字节输入流的抽象类，是所有字节输入流的父类。InputStream类的具体层次结构如图所示： 该类中所有方法遇到错误时都会引发IOException异常。下面是对该类
JAVA多线程读写文件如何做到线程安全？（文件锁，FileChannel）
热门推荐
奋斗的IT青年
08-17 1万+
使用对文件加锁的方式做到线程安全 FileInputStream、FileOutputStream、RandomAccessFile均可得到FileChannel对象，对文件锁进行操作。 独占锁tryLock() FileChannel的tryLock()是非阻塞的，也就是说，在发现文件被锁住的时候，直接返回null，并且抛出异常，如果没有锁住，直接返回该文件的文件锁。 它是独占锁，就是只能被一个线程持有，它能禁止 在JAVA的标准I/O中，提供了基于流的I/O实现，即InputStream和Out...
FileInputStream.read和FileChannel.read的区别
以爱护甲,爱满枫林。
04-28 771
原来 FileInputStream的read并没有像FileChannel的read那样加锁，底层使用的是native方法readBytes，那是不是他们两者底层实现就一定不相同呢，不要下这么早的结论，我们看jdk源码，步骤大致像上述那样，但是有些区别，先进入。不同点：FileInputStream的read方法是非线程安全的，FileChannel的read方法是线程安全的。原来 FileInputStream的read方法底层也是调用的ReadFile方法.这次选择jdk8u-dev。
Java线程安全
02-23
在多线程环境下，不同线程对同一份数据操作，就可能会产生不同线程中数据状态不一致的情况，这就是线程安全问题的定义或者说原因。要实现线程安全，需要保证数据操作的两个特性：原子性：对数据的操作不会受其他线程...
Java线程安全.docx
最新发布
10-24
"Java线程安全" Java线程安全是指在多线程并发编程中，如何确保线程安全地访问和修改共享资源的问题。Java内存模型（JMM）是Java虚拟机（JVM）定义的内存模型，旨在屏蔽底层平台的内存管理细节，提供了一个统一的...
Java线程安全中的单例模式
09-03
本篇文章将详细探讨Java线程安全中的单例模式。 首先，我们来看给定代码中的一种实现方式，也被称为"静态内部类"或"双检锁"（Double-Checked Locking）模式。这段代码如下： ```java package net.kitbox.util; ...
IO流_一些理解
qq_57559877的博客
06-15 1019
一. 1. public abstract class InputStream extends Object implements Closeable 这个抽象类是表示输入字节流的所有类的超类。 需要定义InputStream子类的应用InputStream必须始终提供一种返回输入的下一个字节的方法。 2. public abstract class OutputStream extends Object implements Closeable, Flushable 这个抽象类是...
多线程_IO流
Awww_20的博客
08-28 592
每周学习内容总结
85.Andorid Http【多线程】【该方法在InputStream获取的时候存在小Bug】
02-05 177
该案例是从网络下载一张图片 1.异常1 该异常的意思是不能在主线程里使用Network(网络)。所以需要单独开启一个线程操作。 2.异常2 该异常的意思是子线程中不可以修改主线程中的UI。所以线程之间只能有消息参数传递，而不能直接操作其他线程中的元素。 这里需要使用到一个Handler对象，并重构它的handleMessage(Message msg)方法 ...
多线程Socket的InputStream的困扰一天才解决的问题
qq_37340753的博客
07-18 9048
多线程Socket的InputStream的问题 这几天都在开发一个学生时代的一个小项目(SSH开发)，导致没有时间去学习理论基础。没错，我汇编都还不太懂就开发了(就更别说我懂操作系统了)，这导致在写项目的时候遇到很多瓶颈。当自己想写一个程序实现一个底层功能的时候发现特别鸡肋。 因此，写一篇自己遇到的一个底层与单片机通信的问题。 在这里大家发现了，单片机怎么用socket来做呢？没错，大家挺...
关于Java OutputStream 线程安全问题
魏帅超的专栏
01-07 8742
今天偶尔发现java的输出流的线程安全问题 先看代码吧 import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStream; import java.util.Random; import java.util.concurrent.Ti
java bytearray 线程安全_关于Java OutputStream 线程安全问题
weixin_42363565的博客
02-13 466
今天偶尔发现java的输出流的线程安全问题先看代码吧import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.OutputStream;import java.util.Random;import java.util.concurrent.TimeUnit;pu...
Java——使用多线程模拟真实高并发业务并保证安全性（一）
前方一片光明
07-19 8361
使用100个线程往list中添加10000条数据，要求保证安全性，并正确记录数量。
Io及多线程
小么飞刀的博客
10-25 843
IO流 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种：输入流，输出流。 流按操作类型分为两种：字节流与字符流。  字节流可以操作任何数据，字符流只能操作纯字符数据，比较方便。 2.IO流常用父类 字节流的抽象父类： InputStream ，OutputSt
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值