java多线程跑批更新数据 java多线程更新数据库

一般来说java多线程实现方法一般有三个
我们在讲这个之前，我们先来了解一下操作系统的一些知识，串行和并行我们以前写代码都知道你写的代码都是按照一行一行来执行的是吧！来点现实中的例子，我们来举一个例子。
吃饭喝水：我们肯定是要么先吃饭然后在喝水要么先喝水在吃饭对吧，可以同时吃饭和喝水吗？你可以尝试一下（不要钻牛角尖）
上厕所玩手机：上厕所当然可以边玩手机对吧，可是在那个瞬间，你真的可以在你大脑中准确的执行同时拉屎和玩手机呢？我们只可以说在一段极短的时间内，我们是同时在做拉屎和玩手机的动作！
我们通俗的讲就是微观串行宏观并行！

我们的cpu也是一样的和大脑一样，在某个时刻某个瞬间，cup只能执行一条指令。在一段时间内（极短）通过时间片轮来去执行每个指令。

下面是java多线程的简单实现

继承Thread

public class ThreadTest extends Thread {

    @Override
    public void run() {
        for (int i=0; i <= 2000; i++){
            System.out.println("我是线程1");
        }

    }

    public static void main(String[] args){
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
        for (int i=0; i <= 2000; i++){
            System.out.println("我是线程3");
        }
    }
}

实现Runnable接口

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "，我正在运行！");
        }
    }

    public static void main(String[] args){
        RunnableTest runnableTest = new RunnableTest();

        new Thread(runnableTest, "Jack").start();
        new Thread(runnableTest, "Tom").start();
        new Thread(runnableTest, "Anna").start();
    }
}

归纳上面两种，重点

实现Callable接口（了解即可）（这个以后工作会常用）

import java.util.concurrent.*;

public class CallableTest implements Callable<Boolean> {

    private String name;

    public CallableTest(String name){
        this.name = name;
    }

    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 20; i++) {
            System.out.println(name + "我们正在运行！");
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableTest callableTest = new CallableTest("Jock");  // 创建对象
        CallableTest callableTest2 = new CallableTest("Tom");
        CallableTest callableTest3 = new CallableTest("Anna");


        // 创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);  //  线程池

        // 提交任务并且执行
        Future<Boolean> future = executorService.submit(callableTest);
        Future<Boolean> future2 = executorService.submit(callableTest2);
        Future<Boolean> future3 = executorService.submit(callableTest3);

        // 获取结果
        boolean b = future.get();
        boolean b2 = future2.get();
        boolean b3 = future3.get();

        // 关闭服务
        executorService.shutdown();
    }
}

以上就是java的这么几种实现多线程的方法。

线程的几种状态

线程停止

public class StopThread implements Runnable{

    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println("子线程进行到了" + i++);
        }
    }

    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) throws InterruptedException {
        StopThread stopThread = new StopThread();
        new Thread(stopThread).start();
        for (int i = 0; i < 1000; i++) {
            if(i == 600){
                stopThread.stop();
                System.out.println("子线程停止");
            }
            System.out.println("主线程进行到了" + i);
        }
    }
}

线程休眠

```python
import java.text.SimpleDateFormat;
import java.util.Date;

public class SleepTest extends Thread{

    public static void main(String[] args) throws InterruptedException {
        SimpleDateFormat dateFormat= new SimpleDateFormat("hh:mm:ss");
        for (int i = 0; i < 20; i++) {
            Date date = new Date();
            sleep(1000);  // 线程休眠
            System.out.println(dateFormat.format(date));
        }
    }
}

线程礼让

public class YiledTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始运行");
        Thread.yield(); // 礼让
        System.out.println(Thread.currentThread().getName() + "线程停止运行");
    }

    public static void main(String[] args){
        YiledTest yiledTest = new YiledTest();
        new Thread(yiledTest, "a").start();
        new Thread(yiledTest, "b").start();


    }

}

线程插队

public class JoinTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 600; i++) {
            System.out.println("我是svip线程-->" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        Thread thread = new Thread(joinTest);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我是普通线程-->" + i);
            if(i == 200){
                thread.join();
            }
        }
    }
}

查询线程状态

public class StateTest implements Runnable{
    @Override
    public void run() {
        System.out.println("我又开始了");
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("我又开始了");
    }

    public static void main(String[] args){
        StateTest stateTest = new StateTest();
        Thread thread = new Thread(stateTest);
        thread.start();
        Thread.State state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED){
            state = thread.getState();
            System.out.println(state);
        }

    }
}

线程优先级

对于这个，还是回到上CPU问题。线程的运行还是由CPU来分配的，这里给线程分配优先级仅仅只是在概率上提高，优先执行它的可能大大提高！

public class SeeTest implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());
    }

    public static void main(String[] args){  // 线程1-10权限
        SeeTest seeTest = new SeeTest();
        Thread thread = new Thread(seeTest);
        thread.setPriority(1);
        thread.start();
        Thread thread2 = new Thread(seeTest);
        thread2.setPriority(10);
        thread2.start();
        Thread thread3 = new Thread(seeTest);
        thread3.setPriority(7);
        thread3.start();
        Thread thread4 = new Thread(seeTest);
        thread4.setPriority(4);
        thread4.start();
        Thread thread5 = new Thread(seeTest);
        thread5.start();
        Thread thread6 = new Thread(seeTest);
        thread6.start();
        Thread thread7 = new Thread(seeTest);
        thread7.start();
        Thread thread8 = new Thread(seeTest);
        thread8.start();
        Thread thread9 = new Thread(seeTest);
        thread9.start();
        Thread thread10 = new Thread(seeTest);
        thread10.start();
    }
}

线程守护

对于这个你可以联想一下java的垃圾回收机制（gc）和main（主方法）
守护线程就是为了确保用户线程可以正常运行的一个线程

public class DaemonTest {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);
        thread.start();

        new Thread(you).start();
    }
}

class God implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println("上帝保佑你！");
        }
    }
}

class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你来到了这个世界");
        }

        System.out.println("再见！");
    }
}