java----多线程

1.什么是线程和进程？

进程好比一个软件，线程好比软件中的一个功能。一个进程包含了多个线程，

举例:

比如360软件中木马查杀；买票的时候，火车站就是一个进程，各个窗口表示线程。

并行与并发之间的区别:

好比做饭吧，几个厨师分别同时做不同的食物 ------------------- 并行 --------------------------------------   在同一时刻，有多个指令在多个CPU上同时执行

一个人在做在做很多食物，不停地交换     ------------------------并发---------------------------------        在同一时刻，有多个指令在单个CPU上交替执行

之所以提出java多线程，就是为了提高它的运行效率。

多线程的实例:

比如你每次更新王者荣耀，需要加载东西还要放出音乐。这就是两个线程

2.使用java语言进程多线程代码编写

使用Java语言编写多线程的方法一共有三种

第一种:通过继承类Thread

• 方法名	说明
  void run()	在线程开启后，此方法将被调用执行
  void start()	使此线程开始执行，Java虚拟机会调用run方法()

相关代码如下:

按照顺序依次编写相关代码

- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程

 public class thred01  extends Thread{
   public void run(){
        for (int i = 0; i <=10; i++) {
            System.out.println(getName()+"hello  world");
        }
    }

}

/**
 * 第一种方式进行多线程
 */
thred01 t = new thred01();
thred01 t2 = new thred01();
thred01 t3 = new thred01();
t.setName("线程1");
t2.setName("线程2");
t3.setName("线程3");
t.start();
t2.start();
t3.start();

两个小问题

- 为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

- run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

显示效果:

2.第二种方法implements Runnable

• 实现步骤

  • 定义一个类MyRunnable实现Runnable接口

  • 在MyRunnable类中重写run()方法

  • 创建MyRunnable类的对象

  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数

  • 启动线程

public class myrun implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"hello world");
        }
    }
}

//        myrun my = new myrun();
//        Thread t = new Thread(my);
//        Thread t2 = new Thread(my);
//        t.setName("线程1");
//        t2.setName("线程2");
//        t.start();
//        t2.start();

3.通过Callable接口来实现多线程

| 方法名                           | 说明                                               |
| -------------------------------- | -------------------------------------------------- |
| V call()                         | 计算结果，如果无法计算结果，则抛出一个异常         |
| FutureTask(Callable<V> callable) | 创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get()                          | 如有必要，等待计算完成，然后获取其结果             |

+ 定义一个类MyCallable实现Callable接口
+ 在MyCallable类中重写call()方法
+ 创建MyCallable类的对象
+ 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
+ 创建Thread类的对象，把FutureTask对象作为构造方法的参数
+ 启动线程
+ 再调用get方法，就可以获取线程结束之后的结果。


public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        String s = ft.get();
        //开启线程
        t1.start();

        //String s = ft.get();
        System.out.println(s);
    }
}

关于多线程的一些方法:

void setName(String name)                               将此线程的名称更改为等于参数name 
String getName()                                              返回此线程的名称
Thread currentThread()                                    返回对当前正在执行的线程对象的引用 

static void sleep(long millis)使当前正在执行的线程停留（暂停执行）       指定的毫秒数