博客

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

介绍一下java开启多线程的方式，和解决数据安全的思路。都是比较基础的东西。

一、继承Thread并重写run方法，并调用start方法

子类代码：

package com.example.myblog.test;

public class ThreadTest extends Thread{

    @Override
    public void run() {
        //此处为thread执行的任务内容
        System.out.println(Thread.currentThread().getName());
    }
}

测试类代码：

	@Test
    public void threadTest(){
        //开启三个线程
        for(int i=0;i<3;i++){
            Thread thread = new ThreadTest();
            thread.start();
        }

    }

测试结果：

二、实现Runnable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法

实现类代码：

package com.example.myblog.test;

public class RunnableTest implements Runnable{

    @Override
    public void run() {
        //此处为thread执行的任务内容
        System.out.println(Thread.currentThread().getName());
    }
}

测试类代码：

@Test
    public void runnableTest(){
        //开启三个线程
        for(int i=0;i<3;i++){
            Thread thread = new Thread(new RunnableTest());
            thread.start();
        }
    }

测试结果：

三、实现Callable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法

实现类代码：

package com.example.myblog.test;

import java.util.concurrent.Callable;

public class CallableTest implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        //返回值
        return Thread.currentThread().getName();
    }
}

测试类代码：

@Test
    public void callableTest(){
        //开启三个线程
        for(int i=0;i<3;i++){
            //创建MyThread实例
            Callable<String> callable = new CallableTest();
            //获取FutureTask
            FutureTask<String> ft = new FutureTask<String>(callable);
            //使用FutureTask初始化Thread
            Thread t = new Thread(ft);
            //Thread-0 Thread-1
            t.start();
            //接受返回值
            try {
                String result = ft.get();
                //打印返回值
                System.out.println(result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

    }

测试结果：

四、多线程数据安全

多线程共享数据的时候，会出现数据安全的问题。我们可以通过加锁来控制解决这个问题。

synchronized 可以用来修饰普通方法、静态方法和代码块。

当使用 synchronized 加锁 class 时，无论共享一个对象还是创建多个对象，它们用的都是同一把锁，而使用 synchronized 加锁 this 时，只有同一个对象会使用同一把锁，不同对象之间的锁是不同的。

问题代码：

package com.example.myblog.test;

public class SecurityTest implements Runnable{

    private static int num = 100;

    @Override
    public void run() {
        //此处为thread执行的任务内容
        while(true){
            System.out.println(Thread.currentThread().getName() + "@: " + this.num);
            this.num --;
            Thread.yield();   //为了更容易产生错误
            if(this.num < 0){
                break;
            }
        }
    }
}

测试类代码：

@Test
    public void testSecurity(){
        Thread thread1 = new Thread(new SecurityTest());
        thread1.start();
        Thread thread2 = new Thread(new SecurityTest());
        thread2.start();
    }

测试结果：



优化后代码：

package com.example.myblog.test;

import com.example.myblog.MyblogApplication;

public class SecuritysTest implements Runnable{

    private static int num = 10;

    @Override
    public void run() {
        //此处为thread执行的任务内容
        while(true){
            synchronized(SecuritysTest.class){
                if(this.num < 0){
                    break;
                }
                Thread.yield();//为了更容易产生错误
                System.out.println(Thread.currentThread().getName() + "@: " + this.num);
                this.num --;
            }
        }
    }
}

测试类代码：

 @Test
    public void testSecuritys(){
        Thread thread1 = new Thread(new SecuritysTest());
        thread1.start();
        Thread thread2 = new Thread(new SecuritysTest());
        thread2.start();
    }

测试结果：