我们知道java有一个特性，多线程，它是一个同时运行多个线程的过程。 当多个线程处理相同的数据，并且我们的数据值发生变化时，这种情况不是线程安全的，我们会得到不一致的结果。 当一个线程已经在一个对象上工作并阻止另一个线程在同一个对象上工作时，这个过程称为线程安全。
在java中，通过如下方法实现线程安全：
- 使用线程同步
- 使用volatile关键字
- 使用atomic变量
- 使用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