Java中实现线程安全的几种方法

我们知道Java有一个特性,多线程,它是一个同时运行多个线程的过程。 当多个线程处理相同的数据,并且我们的数据值发生变化时,这种情况不是线程安全的,我们会得到不一致的结果。 当一个线程已经在一个对象上工作并阻止另一个线程在同一个对象上工作时,这个过程称为线程安全。

在Java中,通过如下方法实现线程安全:

  1. 使用线程同步
  2. 使用Volatile关键字
  3. 使用Atomic变量
  4. 使用final关键字

使用线程同步

同步是一次只允许一个线程完成特定任务的过程。 意思是当多个线程同时执行,想要同时访问同一个资源时,就会出现不一致的问题。 因此同步用于通过一次只允许一个线程来解决不一致问题。

同步使用 synchronized 关键字。 Synchronized是作用与同步区域的修饰符。

class A {
  synchronized void sum(int n)
  {

    // Creating a thread instance
    Thread t = Thread.currentThread();
    for (int i = 1; i <= 5; i++) {
      System.out.println(
        t.getName() + " : " + (n + i));
    }
  }
}

// Class B extending thread class
class B extends Thread {

  // Creating an object of class A
  A a = new A();
  public void run()
  {

    // Calling sum() method
    a.sum(10);
  }
}
class Test {
  public static void main(String[] args)
  {

    // Creating an object of class B
    B b = new B();

    // Initializing instance t1 of Thread
    // class with object of class B
    Thread t1 = new Thread(b);

    // Initializing instance t2 of Thread
    // class with object of class B
    Thread t2 = new Thread(b);

    // Initializing thread t1 with name
    //'Thread A'
    t1.setName("Thread A");

    // Initializing thread t2 with name
    //'Thread B'
    t2.setName("Thread B");

    // Starting thread instance t1 and t2
    t1.start();
    t2.start();
  }
}

输出

Thread A : 11
Thread A : 12
Thread A : 13
Thread A : 14
Thread A : 15
Thread B : 11
Thread B : 12
Thread B : 13
Thread B : 14
Thread B : 15

使用Volatile关键字

volatile 关键字是一个字段修饰符,可确保对象可以被多个线程同时使用而不会出现任何问题。 volatile 是确保 Java 程序是线程安全的一种好方法。 volatile 关键字可用作在 Java 中实现线程安全的替代方法。

public class VolatileExample {

  // Initializing volatile variables
  // a, b
  static volatile int a = 0, b = 0;

  // Defining a static void method
  static void method_one()
  {
    a++;
    b++;
  }

  // Defining static void method
  static void method_two()
  {
    System.out.println(
      "a=" + a + " b=" + b);
  }

  public static void main(String[] args)
  {

    // Creating an instance t1 of
    // Thread class
    Thread t1 = new Thread() {
      public void run()
      {
        for (int i = 0; i < 5; i++)
          method_one();
      }
    };

    // Creating an instance t2 of
    // Thread class
    Thread t2 = new Thread() {
      public void run()
      {
        for (int i = 0; i < 5; i++)
          method_two();
      }
    };

    // Starting instance t1 and t2
    t1.start();
    t2.start();
  }
}

输出

a=5 b=5
a=5 b=5
a=5 b=5
a=5 b=5
a=5 b=5

使用Atomic变量

使用原子变量是在 java 中实现线程安全的另一种方法。 当多个线程共享变量时,原子变量确保线程不会相互崩溃。

import java.util.concurrent.atomic.AtomicInteger;

class Counter {

  // Creating a variable of
  // class type AtomicInteger
  AtomicInteger count
    = new AtomicInteger();

  // Defining increment() method
  // to change value of
  // AtomicInteger variable
  public void increment()
  {
    count.incrementAndGet();
  }
}

public class TestCounter {
  public static void main(
    String[] args) throws Exception
  {

    // Creating an instance of
    // Counter class
    Counter c = new Counter();

    // Creating an instance t1 of
    // Thread class
    Thread t1 = new Thread(
      new Runnable() {
        public void run()
        {
          for (int i = 1; i <= 2000; i++) {
            c.increment();
          }
        }
      });

    // Creating an instance t2
    // of Thread class
    Thread t2 = new Thread(
      new Runnable() {
        public void run()
        {
          for (int i = 1; i <= 2000; i++) {
            c.increment();
          }
        }
      });

    // Calling start() method with t1 and t2
    t1.start();
    t2.start();

    // Calling join method with t1 and t2
    t1.join();
    t2.join();

    System.out.println(c.count);
  }
}

输出

4000

使用final关键字

final变量在 java 中也是线程安全的,因为一旦分配了一个对象的某个引用,它就不能指向另一个对象的引用。

public class FinalTest {

  // Initializing a string
  // variable of final type
  final String str
    = new String("hello");

  // Defining a method to
  // change the value of the final
  // variable which is not possible,
  // hence the error will be shown
  void method()
  {
    str = "world";
  }
}

输出

Compilation Error in java code :- 
prog.java:14: error: cannot assign a value to final variable str
        str = "world";
        ^
1 error
  • 0
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
### 回答1: 使用 Java 实现线程有两种方法: 1. 实现 Runnable 接口:通过实现 Runnable 接口并重写其 run() 方法来创建线程。 2. 继承 Thread 类:通过继承 Thread 类并重写其 run() 方法来创建线程。 两种方法都是可行的,但是通常推荐使用实现 Runnable 接口的方法,因为继承了 Thread 类会导致继承树不再继续向上延伸,进而影响代码的复用性。 ### 回答2: 在Java实现线程有三种主要方法: 1. 继承Thread类:这是最基本的方法,需要创建一个继承自Thread类的子类,并重写其的run()方法。run()方法定义了线程执行的具体逻辑。然后可以通过创建子类对象,并调用其start()方法来启动线程。 2. 实现Runnable接口:这是另一种常见的方法,需要创建一个实现了Runnable接口的类,并实现的run()方法。然后可以将该实现类的对象作为参数传递给Thread类的构造方法,在构造Thread对象时将其包装成一个线程对象。然后调用线程对象的start()方法来启动线程。 3. 实现Callable接口:这是Java5版本之后引入的新特性。Callable接口与Runnable接口相似,都是定义了一个run()方法来执行线程的逻辑。但是不同的是,run()方法的返回值为void,而Callable的call()方法可以有返回值。使用Callable需要创建一个实现了Callable接口的类,并实现的call()方法。然后可以通过将该实现类的对象作为参数传递给ExecutorService类的submit()方法来启动线程,并获取call()方法的返回值。 以上是最常见的三种方法实现线程。不同的方法适用于不同的场景,通过选择合适的方法可以更灵活地管理和控制线程的执行。 ### 回答3: 在Java,有三种主要的方法可以实现线程: 1. 继承Thread类:创建一个新的类,继承Thread类,并重写run()方法。在run()方法定义线程的逻辑和动作。然后可以创建该类的实例,并调用start()方法来启动新的线程。 2. 实现Runnable接口:创建一个新的类,实现Runnable接口,并重写run()方法。在run()方法定义线程的逻辑和动作。然后可以创建Thread对象,将实现了Runnable接口的类的实例作为参数传递给Thread的构造方法,最后调用start()方法来启动新的线程。 3. 使用Executor框架:Executor框架是Java提供的线程池管理工具。它利用ExecutorService接口来管理线程池。可以使用Executors类的一些静态方法来创建不同类型的线程池。然后使用submit()方法提交一个实现了Runnable接口或Callable接口的对象给线程池,线程池会自动分配线程来执行任务。 无论使用哪种方法实现线程的本质都是通过创建Runnable对象,然后通过线程启动器(Thread类的start()方法或Executor框架)来调度执行。不过,继承Thread类更加直观,但不方便资源共享;而实现Runnable接口可以避免单继承局限,并且可以共享资源;使用Executor框架可以进一步简化线程管理和资源分配。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BigDataToAI

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值