Java >> Java opplæring >  >> Java

Java AtomicReference Eksempel

Java

Dette er et eksempel på AtomicReference klasse av Java. Det er en annen klasse under java.util.concurrent.atomic pakke, som gir en objektreferanse som kan oppdateres atomisk.

AtomicReference klasse gir referanseobjekter som kan leses og skrives atomisk, så når flere tråder prøver å nå dem samtidig, vil bare én kunne gjøre det.

I eksemplet nedenfor har vi laget to tråder som prøver å oppdatere verdiene til et String-objekt, message og et tilpasset klasseobjekt, Person . De oppdaterer også to AtomicReference-objekter, ett opprettet for message , og den andre opprettet for person objekt.

AtomicReference klasse gir noen få metoder for å oppdatere det refererte objektet. Nedenfor bruker vi dem:

  • compareAndSet(V expect, V update) API-metoden setter atomverdien til den gitte oppdaterte verdien, bare hvis gjeldende verdi er lik forventet verdi.
  • getAndSet(V newValue) API-metoden setter atomisk til den gitte verdien og returnerer den gamle verdien.
  • lazySet(V newValue) API-metoden settes til slutt til den gitte verdien.
  • set(V newValue) API-metoden angir den gitte verdien.
  • get() API-metoden får gjeldende verdi.

AtomicReferenceExample.java: 

package com.javacodegeeks.snippets.core;

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {

 private static String message;
 private static Person person;
 private static AtomicReference<String> aRmessage;
 private static AtomicReference<Person> aRperson;
 
 public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(new MyRun1());
 Thread t2 = new Thread(new MyRun2());
 message = "hello";
 person = new Person("Phillip", 23);
 aRmessage = new AtomicReference<String>(message);
 aRperson = new AtomicReference<Person>(person);
 System.out.println("Message is: " + message
 + "\nPerson is " + person.toString());
 System.out.println("Atomic Reference of Message is: " + aRmessage.get()
 + "\nAtomic Reference of Person is " + aRperson.get().toString());
 t1.start();
 t2.start();
 t1.join();
 t2.join(); 
 System.out.println("\nNow Message is: " + message 
 + "\nPerson is " + person.toString());
 System.out.println("Atomic Reference of Message is: " + aRmessage.get()
 + "\nAtomic Reference of Person is " + aRperson.get().toString());
 }
 
 static class MyRun1 implements Runnable {

 public void run() {
 aRmessage.compareAndSet(message, "Thread 1");
 message = message.concat("-Thread 1!");
 person.setAge(person.getAge()+1);
 person.setName("Thread 1");
 aRperson.getAndSet(new Person("Thread 1", 1));
 System.out.println("\n" + Thread.currentThread().getName() +" Values " 
 + message + " - " + person.toString());
 System.out.println("\n" + Thread.currentThread().getName() +" Atomic References " 
 + message + " - " + person.toString());
 } 
 }
 
 static class MyRun2 implements Runnable {

 public void run() {
 message = message.concat("-Thread 2");
 person.setAge(person.getAge()+2);
 person.setName("Thread 2");
 aRmessage.lazySet("Thread 2");
 aRperson.set(new Person("Thread 2", 2));
 System.out.println("\n" + Thread.currentThread().getName() +" Values: " 
 + message + " - " + person.toString());
 System.out.println("\n" + Thread.currentThread().getName() +" Atomic References: " 
 + aRmessage.get() + " - " + aRperson.get().toString());
 } 
 }
 
 static class Person {
 
 private String name;
 private int age;
 
 public Person(String name, int age) {
 this.name = name;
 this.age= age;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public int getAge() {
 return age;
 }
 
 public void setAge(int age) {
 this.age = age;
 } 
 
 @Override
 public String toString() {
 return "[name " + this.name + ", age " + this.age + "]";
 }
 }
 
}

Hvis du kjører eksemplet, vil du se hvordan atomreferanseobjektene oppdateres på en mer konsistent måte.

Message is: hello
Person is [name Phillip, age 23]
Atomic Reference of Message is: hello
Atomic Reference of Person is [name Phillip, age 23]

Thread-1 Values: hello-Thread 2-Thread 1! - [name Thread 1, age 26]

Thread-0 Values hello-Thread 2-Thread 1! - [name Thread 1, age 26]

Thread-1 Atomic References: Thread 2 - [name Thread 1, age 1]

Thread-0 Atomic References hello-Thread 2-Thread 1! - [name Thread 1, age 26]

Now Message is: hello-Thread 2-Thread 1!
Person is [name Thread 1, age 26]
Atomic Reference of Message is: Thread 2
Atomic Reference of Person is [name Thread 1, age 1]


Dette var et eksempel på AtomicReference klasse av Java.

Java Tag