Shulou(Shulou.com)06/01 Report--

This article introduces the knowledge of "how to realize the sharing and cooperation between threads in Java concurrent programming". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. Sharing between threads 1.1 ynchronized built-in locks

Use

Java supports multiple threads to access an object or member variables of an object at the same time

The keyword synchronized can be used to modify methods or in the form of synchronous blocks

It mainly ensures that there are multiple threads at the same time, and only one thread is in a method or synchronization block.

It ensures the visibility and exclusiveness of thread access to variables (atomicity, visibility, ordering), also known as the built-in locking mechanism.

Object lock and class lock

Object locks are used on object instance methods, or on an object instance

Class locks are used on static methods of a class or on class objects of a class

There can be many object instances of a class, but each class has only one class object, so the object locks of different object instances do not interfere with each other, but each class has only one class lock.

Note that, in fact, a class lock is just a conceptual thing, not real. A class lock actually locks the corresponding class object of each class.

Class locks and object locks also do not interfere with each other.

1.2 volatile keyword

The lightest synchronization mechanism ensures visibility and does not guarantee atomicity

Volatile ensures the visibility of different threads when operating on this variable, that is, one thread modifies the value of a variable, and the new value is immediately visible to other threads.

The most suitable scenario for volatile: a scenario in which only one thread writes and multiple threads read

1.3 ThreadLocal

Both ThreadLocal and Synchonized are used to address multithreaded concurrent access.

But there is a fundamental difference between ThreadLocal and synchronized:

Synchronized uses a locking mechanism to make variables or blocks of code accessible to only one thread at a time.

ThreadLocal provides each thread with a copy of the variable, so that each thread does not access the same object at a certain time, thus isolating the data sharing of multiple threads.

Spring's transactions rely on the ThreadLocal class.

1.4 Spring transactions rely on the ThreadLocal class

Spring will get a connection from the database connection pool, but it will put the connection into the ThreadLocal, which will be bound to the thread, and the transaction needs to be committed or rolled back, as long as it gets the connection from the ThreadLocal to operate.

1.4.1 Why do Spring transactions rely on the ThreadLocal class? In the case of JDBC, the normal transaction code might be as follows: dbc = new DataBaseConnection (); / / Line 1 Connection con = dbc.getConnection (); / / Line 2 con.setAutoCommit (false); / / Line 3 con.executeUpdate (...); / / Line 4 con.executeUpdate (...); / / Line 5 con.executeUpdate (...); / / Line 6 con.commit () Line 7 the above code can be divided into three parts: transaction preparation phase: line 1-3 business processing phase: line 4-6 transaction commit phase: line 7

Whether we start a transaction or execute a specific sql, we need a specific database connection.

Development applications generally use a three-tier structure, and our Service will call a series of DAO to operate on the database multiple times, so we cannot control the transaction boundary at this time, because in practical applications, the number of DAO called by our Service is uncertain and can vary according to needs, and there may also be cases where Service calls Service.

If you don't use ThreadLocal, how do you get three DAO to connect using the same data source? We must pass the same database connection for each DAO, either as a parameter to the constructor when the DAO is instantiated, or as a parameter to the method in the instance method of each DAO.

Connection conn = getConnection (); Dao1 dao1 = new Dao1 (conn); dao1.exec (); Dao2 dao2 = new Dao2 (conn); dao2.exec (); Dao3 dao3 = new Dao3 (conn); dao3.exec (); conn.commit ()

In order for this database connection to be passed across phases without explicitly passing parameters, another approach must be used.

In the Web container, each complete request cycle is handled by a thread. Therefore, if we can bind some parameters to threads, we can achieve cross-level parameter sharing (implicit sharing) in the software architecture. JAVA happens to provide a method of binding-using ThreadLocal.

The combination of IOC and AOP in Spring can solve this problem very well.

As long as you put a database connection into ThreadLocal, as long as the current thread executes, as long as there is a place to use the database connection, you can get it from ThreadLocal.

1.4.2 use of ThreadLocal

Void set (Object value)

Sets the value of the thread local variable for the current thread.

Public Object get ()

This method returns the thread local variable corresponding to the current thread.

Public void remove ()

The value of the current thread local variable is deleted in order to reduce the memory footprint, which is a new method in JDK 5.0.

It should be pointed out that when the thread ends, the local variables of the corresponding thread will be automatically garbage collected.

So it is not necessary to explicitly call this method to clear the thread's local variables, but it can speed up memory collection.

Protected Object initialValue ()

Returns the initial value of the thread's local variable

This method is a protected method, obviously designed to allow subclasses to override.

This method is a deferred invocation method that is executed only once when the thread first calls get () or set (Object).

The default implementation in ThreadLocal returns a null directly.

Public final static ThreadLocal RESOURCE = new ThreadLocal ()

RESOURCE represents a ThreadLocal object that can hold String types.

At this time, no matter any thread can access this variable concurrently, it is thread-safe to write and read it.

1.4.3 the ThreadLocal implementation parses the public class ThreadLocal {/ / get method, in fact, it takes the unique ThreadLocalMap / / of each thread, then uses the current instance of ThreadLocal, gets the corresponding Entry in the Map, and then gets the corresponding value to return out. / / if the Map is empty, the map will be created and initialized first. Public T get () {/ / fetch the current thread first, and then call the getMap method to get the corresponding thread's ThreadLocalMap Thread t = Thread.currentThread (); ThreadLocalMap map = getMap (t); if (map! = null) {ThreadLocalMap.Entry e = map.getEntry (this) If (e! = null) {@ SuppressWarnings ("unchecked") T result = (T) e.value; return result;}} return setInitialValue ();} / / there is a member of type ThreadLocalMap in the Thread class, so getMap is the member ThreadLocalMap getMap (Thread t) {return t.threadLocals that directly returns Thread. } / / ThreadLocalMap is ThreadLocal's static inner class static class ThreadLocalMap {ThreadLocalMap (ThreadLocal firstKey, Object firstValue) {/ / saves Entry in an array, because there may be multiple variables that need to be accessed in isolation by threads, that is, declare multiple ThreadLocal variables table = new entry _ CAPACITY]; int I = firstKey.threadLocalHashCode & (INITIAL_CAPACITY-1) / / Entry is similar to the key-value structure of map / / key is ThreadLocal, and value is the variable table [I] = new Entry (firstKey, firstValue); size = 1; setThreshold (INITIAL_CAPACITY) }.} / / Entry internal static class, which inherits WeakReference, / / in short, it records two messages, one is the ThreadLocal type, and the other is the value static class Entry extends WeakReference of the Object type

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.