个人总结-----多线程

一 一些基本概念

首先说一下并发和并行的区别
并发就是多个线程使用统一资源，是单核cpu，比如只有一台电脑，多个人交替着玩
并行是每个线程使用一个单独的cpu资源运行，是多核CPU，比如一人一台电脑，一起玩

接下来说一下进程和线程之间的区别和联系
进程是计算机正在进行的一个独立程序，是动态的。如果一个应用程序 （exe文件）没有运行，那就不是进程
线程是组成进程的基本单位，有特定功能。

区别： 从内存上说，进程是独立的，有自己的专属空间，而线程是在共享的空间。
从安全方面说，进程是安全的一个进程崩溃不会影响其他进程，也就符合他们的独立性。而线程不如进程安全，一个线程崩溃可能导致其他线程奔溃。

二 Java怎末创建线程

1.实现Runable接口

/**
 * 线程的创建通过实现Runable的接口
 */
public class ImplRunable implements Runnable{
    @Override
    public void run() {
        //Thread.currentThread().getName()  打印当前线程的名字
        System.out.println(Thread.currentThread().getName()+"《》实现Runable接口");
    }
}

ImplRunable runable = new ImplRunable();
        //创建线程实例
        Thread thread = new Thread(runable);
        //start()方法启动子线程
        thread.start();
        System.out.println(Thread.currentThread().getName()+"《》主线程main");

2.继承Thread

/**
 * 通过继承Thread类创建多线程
 */
public class DIYThread extends Thread {

    //重写run方法
    @Override
    public void run() {
        //子线程的业务都在run方法中
        System.out.println(Thread.currentThread().getName()+">>通过继承Thread类创建多线程");
    }
}
/**
         * 通过继承Thread类创建多线程
         */
        DIYThread thread1 = new DIYThread();
        thread1.start();
        System.out.println(Thread.currentThread().getName()+">>主线程main");

3.实现Callable接口（这是一个泛型接口）

该接口的实现类是无法直接使用的，需要接口FutureTask类
FutureTask类是继承Runable接口，即FutureTask是Runable接口的实现类，而FutureTask类提供了构造函数FutureTask(Callable
callable) ，可以接口Callable类型的任务
可以通过FutureTask类将Callable类型的任务转化为Runable类型的任务

/**
 * 通过Callable接口来实现多线程
 */
public class ImplCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName()+":>>通过Callable接口来实现多线程");
        return "这就是callable";
    }
}

/**
         * 通过实现Callable接口方式创建多线程
         */
        //Callable类型的实例=>任务体
        ImplCallable callable = new ImplCallable();

        //需要一个将Callable类型转化为Runable类型的类
        FutureTask <String> futureTask = new FutureTask <>(callable)
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(Thread.currentThread().getName()+":>>main函数");

三 线程的几种状态

1.新建状态new
线程刚刚创建，占了一些内存
2.就绪状态Runable
线程被创建之后，调用了start方法，此时等待CPU的调用
3.运行状态Running
只能是就绪状态的线程获取到CPU资源，执行线程代码
4.阻塞状态blocked
线程由于一些原因放弃了CPU使用权，io，锁等 暂停运行
5.等待状态waiting
当前线程调用了wait方法，JVM就会让此线程进入等待池中
6.超时等待timed-waiting
sleep(long time),join(long time)会使线程处于睡眠状态
7.终止状态terminated
当线程执行到run()方法结尾处，就进入到终止状态，该状态表示线程的生命周期的结束

关键字

下面说一下多线程中几个重要的关键字，用来修饰变量或修饰方法。
首先说一下volatile关键字****
volatile关键字只能修饰基本变量，作用就是保证内存可见性
那说一下可见性和原子性：
可见性：一个变量被多个线程共享，如果一个线程修改了这个变量，其他线程就立刻知道
原子性：一个操作是不可分割的
再说一下synchronized关键字 ，是一种锁
1.
如果synchronized锁一个对象，那么作用就在代码块上

  //修饰代码块
    public void test1(Object o) {
        synchronized (o) {
            //这就是被作用的地方
        }
    }

如果synchronized锁的是普通方法，那锁的就是它的对象实例

  //修饰普通方法
    public synchronized void  test2() {
         
    }

如果synchronized锁的是静态方法，那锁的就是当前类的实例。

/修饰静态方法
    public synchronized static void  test3() {
     
    }

Synchronized的特点
Synchronized修饰的方法或者代码块，同一时刻只允许一个线程访问，这就是锁。