`
liyong1989
  • 浏览: 9957 次
  • 性别: Icon_minigender_1
  • 来自: 江西
文章分类
社区版块
存档分类
最新评论

ThreadLocal用法解析(转载)

阅读更多
java的同步机制,大概是通过
1.synchronized;
2.Object方法中的wait,notify;
3.ThreadLocal机制
来实现的
其中synchronized有两种用法
1.对类的方法进行修饰
2.synchronized(对象)的方法进行修饰

所以我们这里有好几种场景,现在我对每个场景都举个例子说明,并且指出哪个例子是说明哪个场景的。最后说为什么需要ThreadLocal,以及ThreadLocal的用法。例子结合了从网上找的资料。

所有场景都要用到的类


package threadlocal.test;

public class Student {
    private int age = 0;

    public int getAge() {
        return this.age;

    }

    public void setAge(int age) {
        this.age = age;
    }
}




一,第一个应用场景,无任何同步机制,整个程序运行时间约为5秒




package threadlocal.test;

import java.util.Random;

public class ThreadDemo1 implements Runnable {
    Student student = new Student();

    public static void main(String[] agrs) {
        ThreadDemo1 td = new ThreadDemo1();
        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");
        t1.start();
        t2.start();

    }

    public void run() {
        accessStudent();
    }

    public void accessStudent() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        Random random = new Random();
        int age = random.nextInt(100);
        System.out
                .println("thread " + currentThreadName + " set age to:" + age);

        this.student.setAge(age);
        System.out.println("thread " + currentThreadName
                + " first read age is:" + this.student.getAge());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("thread " + currentThreadName
                + " second read age is:" + this.student.getAge());

    }

}



简述:两个线程同时开启,对同一个类实例进行操作,虽然速度很快,只占用一个线程运行时间,但是出现竞争使得整个代码变得无用。



二,第二个应用场景,synchronized修饰类方法。程序运行时间约为10秒



package threadlocal.test;

import java.util.Random;

/**
* 加了个synchronized,不会出现竞争了,但是效率极低
*
* @author dachuan
*
*/
public class ThreadDemo2 implements Runnable {
    Student student = new Student();

    public static void main(String[] agrs) {
        ThreadDemo2 td = new ThreadDemo2();

        // ThreadDemo2 td = new ThreadDemo2();

        // ThreadDemo2 td2 = new ThreadDemo2();


        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");
        //之所以t1,t2两个线程会在acessStudent函数处出现同步,是因为他们都是对同一个实例的函数进行访问

        //t1,t2都在对ThreadDemo2这个类的实例td的函数accessStudent进行访问,所以会出现同步。

        //也就是说,如果类A内部定义了一个synchronized方法,而a是A的一个实例,如果有不同的线程都对a.syn()进行访问,就会出现同步

        //synchronized关键字是锁住了类的实例,让另外的线程进不去

        //在这个例子中,t1,t2两个线程,总共运行时间肯定>=10秒,因为t1,t2在accessStudent这个地方是串行的。

        //如果t1,t2是为了完成某件事情在合作,那么这个同步是值得的。

        //现在的前提是,t1,t2必须使用同一个类的实例,但是又做的都是独立的事情。这个时候,synchronized方法显得很低效,反而降低了运算效率

        //所以ThreadLocal的出现就是为了解决这个问题的。

        //ThreadLocal的应用场合:

        //1.多个线程都要使用同一个类实例

        //2.这多个线程拿到这个类实例后做的事情是互相独立的

        //生产者和消费者模型跟ThreadLocal的应用场合有一个区别

        //1.生产者和消费者两个线程其实也是在使用同一个类实例

        //2.但是这两个线程拿到类实例后做的事情是互相牵制的

        t1.start();
        t2.start();

    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Runnable#run()
     */
    public void run() {
        accessStudent();
    }

    public synchronized void accessStudent() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        // System.out.println("first read age is:"+this.student.getAge());

        Random random = new Random();
        int age = random.nextInt(100);
        System.out
                .println("thread " + currentThreadName + " set age to:" + age);

        this.student.setAge(age);
        System.out.println("thread " + currentThreadName
                + " first read age is:" + this.student.getAge());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("thread " + currentThreadName
                + " second read age is:" + this.student.getAge());

    }

}



简述:两个线程在accessStudent方法处串行操作,所以整个程序时间变长,大约10秒。消除了竞争



三,第三个应用场景,synchronized修饰类,程序运行时间大约10秒。



package threadlocal.test;

import java.util.Random;

/**
*
* @author dachuan
*
*/
public class ThreadDemo3 implements Runnable {
    Student student = new Student();

    public static void main(String[] agrs) {
        ThreadDemo3 td = new ThreadDemo3();
        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");
        t1.start();
        t2.start();

    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Runnable#run()
     */
    public void run() {
        accessStudent();
    }

    public void accessStudent() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        // System.out.println("first read age is:"+this.student.getAge());

        synchronized (this) {

            Random random = new Random();
            int age = random.nextInt(100);
            System.out.println("thread " + currentThreadName + " set age to:"
                    + age);

            this.student.setAge(age);
            System.out.println("thread " + currentThreadName
                    + " first read age is:" + this.student.getAge());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("thread " + currentThreadName
                + " second read age is:" + this.student.getAge());

    }

}




简述:synchronized关键字都是用来锁住对象的,这个地方锁住了this,两个线程访问的都是同一个类实例,所以两个线程中的this都是指一个东西。整个程序无竞争,运行时间大约10秒



四,第四个应用场景,TheadLocal。程序无竞争,运行时间大约5秒




package threadlocal.test;

import java.util.Random;

public class ThreadLocalDemo implements Runnable {
    private final static ThreadLocal studentLocal = new ThreadLocal();

    public static void main(String[] agrs) {
        ThreadLocalDemo td = new ThreadLocalDemo();
        Thread t1 = new Thread(td, "a");
        Thread t2 = new Thread(td, "b");

        t1.start();
        t2.start();

    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Runnable#run()
     */
    public void run() {
        accessStudent();
    }

    public void accessStudent() {

        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName + " is running!");
        Random random = new Random();
        int age = random.nextInt(100);
        System.out
                .println("thread " + currentThreadName + " set age to:" + age);
        Student student = getStudent();
        student.setAge(age);
        System.out.println("thread " + currentThreadName
                + " first read age is:" + student.getAge());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("thread " + currentThreadName
                + " second read age is:" + student.getAge());

    }

    protected Student getStudent() {
        Student student = (Student) studentLocal.get();
        if (student == null) {
            student = new Student();
            studentLocal.set(student);
        }
        return student;
    }

    protected void setStudent(Student student) {
        studentLocal.set(student);
    }
}



简述:ThreadLocal的出现使得两个线程虽然手中握有同一个类的实例,但是做同一样事情的时候却互不干扰。这就是ThreadLocal的应用场景。



五,第五个应用场景,生产者&消费者模型和ThreadLocal模型的区别

我个人总结,ThreadLocal的应用场景为:

1.多个线程都要使用同一个类实例
2.这多个线程拿到这个类实例后做的事情是互相独立的



而生产者消费者例子跟ThreadLocal有一点区别

1.生产者和消费者两个线程其实也是在使用同一个类实例
2.但是这两个线程拿到类实例后做的事情是互相牵制的



所以看到这里,就知道ThreadLocal的应用场景是什么了。



我在阅读Hadoop源码时,看到MapOutputFile这个类中使用了ThreadLocal,所以查了些资料总结了下。



在Hadoop源码中,有一处地方对Object的wait和notify进行了很好的诠释。以后有空再记录一下。
分享到:
评论

相关推荐

    ThreadLocal 用法详解.md

    ThreadLocal 用法详解.md

    ThreadLocal应用示例及理解

    以上就是关于ThreadLocal的基本概念、使用方法、生命周期管理和实际应用示例的详细解释。了解并熟练掌握ThreadLocal可以帮助我们编写出更高效、更安全的多线程代码。在Java并发编程中,ThreadLocal是一个不可或缺的...

    ThreadLocal

    ThreadLocal通常被用来解决线程共享数据时可能出现的并发问题,避免了使用synchronized关键字进行同步控制的复杂性。 在Java中,ThreadLocal的工作原理是为每个线程创建一个单独的存储空间,每个线程可以独立地读写...

    java中ThreadLocal类的使用

    下面我们将深入探讨`ThreadLocal`的工作原理、使用场景以及常见误区。 `ThreadLocal`类的主要方法有以下几个: 1. `void set(T value)`:设置当前线程的线程局部变量的值。 2. `T get()`:返回当前线程的线程局部...

    正确理解ThreadLocal.pdf

    ### 正确理解ThreadLocal:深入解析其工作原理与应用场景 #### 一、ThreadLocal的基本概念 `ThreadLocal`是Java平台提供的一种线程局部变量的解决方案,它为每一个使用该变量的线程都提供了独立的变量副本,使得每...

    threadLocal

    ThreadLocal的使用方法通常是创建一个ThreadLocal实例,然后在需要的地方通过它的`set()`方法设置线程局部变量的值,通过`get()`方法获取该变量的副本。在生命周期结束后,通常需要调用`remove()`方法清除线程的副本...

    threadlocal源码.jpg

    threadlocal源码解析

    ThreadLocal简单Demo

    4. **减少锁的使用**: 当多个线程需要共享同一资源,但每个线程只需要读取自己相关的数据时,`ThreadLocal`可以避免锁的使用,提升效率。 **注意事项** - 使用`ThreadLocal`后,应确保及时清理不再使用的变量,...

    java事务 - threadlocal

    ThreadLocal的使用方法是创建一个ThreadLocal实例,然后通过其set()方法设置线程局部变量,get()方法获取当前线程的该变量值。需要注意的是,ThreadLocal不是线程安全的,它只是保证了线程内部的隔离性,但不负责...

    Java ThreadLocal用法实例详解

    Java ThreadLocal用法实例详解 Java ThreadLocal是Java中的一种线程局部变量机制,用于保存每个线程独有的数据,以避免线程之间的数据共享问题。ThreadLocal的基本使用非常简单,只需要定义一个ThreadLocal变量,...

    Java中ThreadLocal的设计与使用

    理解ThreadLocal的工作原理和使用方法对于编写高效、安全的多线程程序至关重要。 ### ThreadLocal简介 ThreadLocal并非一个线程对象,而是一个线程局部变量的容器。每个线程都有自己的ThreadLocal实例,它们各自...

    java 中ThreadLocal 的正确用法

    * 在使用 ThreadLocal 时,需要确保 initialValue() 方法的正确实现,以避免线程之间的数据共享。 * 在使用 ThreadLocal 时,需要注意避免内存泄漏的问题,例如,在使用完毕后,需要将 ThreadLocal 变量设置为 null...

    java 简单的ThreadLocal示例

    **ThreadLocal的使用方法:** 1. **创建ThreadLocal实例:** 首先,你需要创建一个ThreadLocal类型的实例,这将作为你在每个线程中存储值的容器。 ```java ThreadLocal<String> threadLocal = new ThreadLocal();...

    理解ThreadLocal

    理解ThreadLocal 理解ThreadLocal 理解ThreadLocal 理解ThreadLocal

    ThreadLocal 内存泄露的实例分析1

    在 `LeakingServlet` 的 `doGet` 方法中,如果 `ThreadLocal` 没有设置值,那么会创建一个新的 `MyCounter` 并设置到 `ThreadLocal` 中。关键在于,一旦 `MyCounter` 被设置到 `ThreadLocal`,那么它将与当前线程...

    JDK的ThreadLocal理解(一)使用和测试

    ThreadLocal的用法非常简单,首先创建一个ThreadLocal实例,然后通过`set()`方法设置线程局部变量的值,通过`get()`方法获取该值。需要注意的是,ThreadLocal中的变量并不是存储在堆内存中,而是存储在线程的...

    从ThreadLocal的使用到Spring的事务管理

    本文将深入探讨ThreadLocal的使用以及Spring框架中的事务管理,这两个主题都是Java开发人员必须掌握的关键技能。 首先,让我们了解ThreadLocal。ThreadLocal是Java提供的一种线程绑定变量的工具类,它允许我们在一...

    Java源码解析ThreadLocal及使用场景

    Java源码解析ThreadLocal及使用场景 ThreadLocal是Java中一个非常重要的类,它在多线程环境下经常使用,用于提供线程本地变量。这些变量使每个线程都有自己的一份拷贝,使得多个线程可以独立地使用变量,不会彼此...

Global site tag (gtag.js) - Google Analytics