在Java中实现多线程和线程安全
在Java中实现多线程和线程安全
- 实现多线程的三种方法
-
- 1.继承Thread类
- 2.实现Runnable接口
- 3.Callable和FutureTask来实现
- 将子线程转换为守护线程（后台线程）
- 实现线程安全的三种方式
-
- 1.同步代码块
- 2.同步方法
- 3.显示锁
实现多线程的三种方法
1.继承Thread类
继承Thread类，重写run方法，通过建立一个实例化对象调用其start方法即可开启一个子线程，代码如下：
public class ThreadTest extends Thread{
public static void main(String[] args) {
new ThreadTest().start();
new ThreadTest().start();
}
@Override
public void run() {
for (int i = 1;i<=10;++i){
System.out.println(getName()+":"+ i);
}
}
}
运行结果：
2.实现Runnable接口
该方法与第一个方法类似，同样将子线程运行的代码写在run方法上。
因为Java的单继承特性和多接口实现，与第一种方法对比，显然实现Runnable接口更加灵活。所以此方法比较常用。
public class RunnableTest {
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 1;i<=4;++i){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
public static void main(String[] args) {
new Thread(new MyRunnable()).start();
new Thread(new MyRunnable()).start();
}
}
运行结果同上。
如果子线程代码只运行一次，那么可以用匿名内部类实现可以使代码更加简洁，这里有两种方式实现：
public class ThreadTest{
public static void main(String[] args) {
//第一种实现方式：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1;i<=4;++i){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}).start();
//第二种实现方式：
new Thread(() -> {
for (int i = 1;i<=4;++i){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}).start();
}
3.Callable和FutureTask来实现
这个比较特殊，它与上面两个不同的是：这实现的子线程可以有返回值。
创建步骤：
1.编写类实现Callable接口，实现call方法：
class 类名 implements Callable{
public call() throws Exception{
return T;
}
}
2.用FutureTask包装上面类的实例化对象：
FutureTask future = new FutureTask<>(callable);
3.通过Thread启动线程：
new Thread (future).start();
package com.huilong.Test;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//使用 FutureTask 来包装 Callable 对象
FutureTask<Integer> task = new FutureTask<Integer>(()->{
for ( int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + " " + i);
}
return 10;
});
new Thread(task, "有返回值的线程").start();
//获取线程的返回值
System.out.println("子线程的返回值：" + task.get());
}
}
注意：这里的get方法是会等待结果出来后返回，主线程可能因此堵塞等待返回值
将子线程转换为守护线程（后台线程）
- 守护线程：在所有线程结束后自动关闭
- 调用 Thread 对象的 setDaemon(true) 方法可以将指定线程设置成守护线程；
- 设置为守护线程必须在调用start方法前
public class RunnableTest {
static class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 1;i<=4;++i){
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
public static void main(String[] args) {
Thread thread= new Thread(new MyRunnable());
thread.setDaemon(true);
thread.start();
}
}
实现线程安全的三种方式
1.同步代码块
原理：就是当有程序进入代码块时，这个锁对象o就会被打上标记，执行完区域代码时，标记去除。当其它程序运行到synchronized(o)时，会判断锁对象o是否被打上标记，如果被打上标记，则程序暂停执行，等待锁对象标记消失。
class MyRunnable implements Runnable{
static Object o = new Object();
@Override
public void run() {
synchronized (o) {
for (int i = 1; i <= 4; ++i) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
注意：
1.必须确保它们使用同一个锁对象。
2.这种方法不公平（当多个子程序在等待锁对象标记的消失，在标记消失时，抢到包含标记消失的时刻的时间片的子线程先执行进入同步代码块，这并非先来先到，所以不公平）
2.同步方法
和第一种方法原理类似，用同样的关键字synchronized修饰方法。
class MyRunnable implements Runnable{
public synchronized void print(){
for (int i = 1; i <= 4; ++i) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
@Override
public void run() {
print();
}
}
注意：1.如果是修饰非静态方法，锁对象是this；修饰静态方法时，锁对象是Ticket.class。
2.这方法同样也是不公平。
3.显示锁
这个锁很明显，lock.lock()执行后锁关上，lock.unlock()执行后锁打开。在lock.lock()和lock.unlock()内的代码不会被另一个子线程执行。
1.非公平锁：创建锁时不传参，谁先抢到时间片谁先执行
class MyRunnable implements Runnable{
public static Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
for (int i = 1; i <= 4; ++i) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
lock.unlock();
}
}
2.公平锁：先来先执行。
在创建锁时传递一个true参数即可
public static Lock lock = new ReentrantLock(true);