JAVA线程

JAVA线程的基本概念  （并行与并发）

并行：是指两个事件或多个事件在同一时刻发生生（同时发生）称之为并行

并发：是指两个事件或多个事件在同一时间段内发生（可能是几秒内也可能是一分钟内事件间隔不不会太长）称之为并行

多线程的使用场景

 1. 后台任务,比如游戏服务器 2.定时向大量用户(100W)用户发邮件 3.异步处理: 发微博/记录日志等 4.分布式计算...

线程与进程的区别

进程：是指一个内存中运行的应用程序，每个进程的都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行一个程序及从一个程序的创建，运行到消亡的过程

线程：进程内部的一个独立执行的单元，一个进程可以同时并发多个线程，可以理解为一个进程相当于一个单cpu操作系统，而线程便是这个系统中运行的多个任务

JAVA线程的实现的三个方法

1.通过使用类继承Thread实现里面的run方法来创建线程

public class Diyi extends Thread {//使用Diyi类继承Thread调用里面的run方法
    /*
     * 第一种线程访问方式
     * @see java.lang.diyi
     */
    @Override
    public void run() {//实现run方法
        int a = 10;
    for (int i = 0; i <a ; i++) {
        System.out.println("第一种线程访问方式\t"+i);
    }
        super.run();
    }

    public static void main(String[] args) {
        Diyi diyi = new Diyi();//实例化Diyi
        diyi.start();//开启线程

    }

}

2.通过使用类接口Runnable实现run方法来创建线程（与第一种方法相差不大）

public class Dier implements Runnable {
/*
 * 
 * 第二种进程实现方法
 * @see java.lang.Runnable#run()
 */

    @Override
    public void run() {
        int a = 6;
        for (int i = 0; i < 6; i++) {
            System.out.println("这是第二种线程访问方式"+i);
        }
    }

    public static void main(String[] args) {
        Dier dier = new Dier();//实例化当前对象
        Thread t = new Thread(dier);//实例化当前线程、
        t.start();//开启线程
        Thread t1 = new Thread(dier);//实例化当前线程、
        t1.start();
        System.out.println("******************************************8");
        //通过使用隐藏类实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                int a =4;
                for (int i = 0; i < a; i++) {
                    System.out.println("这是另类的线程调用"+i);
                }
                
            }
        }).start();
    }

}

3.第三种通过进口Callable<Integer>来实现线程（第三种相比前两种有点复杂）

public class Disan implements Callable<Integer> {
    /*
     *第三种实现线程的方法
     * @see java.util.concurrent.Callable#call()
     */
    @Override
    public Integer call() throws Exception {
        int i = 0;
            for (; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
        return i;
    }
public static void main(String[] args) {
    Disan d   = new Disan();//实例化
    //创建任务
    FutureTask<Integer>  f= new FutureTask<>(d);
    //线程池
    ExecutorService e = Executors.newFixedThreadPool(2);
    e.submit(f);
    try {
        Integer integer = f.get();
        System.out.println(integer);
    } catch (InterruptedException | ExecutionException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
}
}

同步线程锁

为了保证每个线程都能正常执行原子操作，Java 引入了线程同步机制（同步监听对象/同步锁/同步监听器/互斥锁）：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。Java 程序运行使用任何对象作为同步监听对象，但是一般把当前并发访问的共同资源作为同步监听对象。