在Java中实现多线程和线程安全

实现多线程的三种方法

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<T>{
	public <T> call() throws Exception{
		return T;
	}
}
2.用FutureTask包装上面类的实例化对象：
FutureTask<T> 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);