java之多线程
1.什么是进程、什么是线程？
进程是一个应用程序，或者一个软件
线程是一个进程中的执行场景、执行单元
一个进程可以启动多个线程。
对于java程序来说，当在dos命令窗口输入：java helloWorld 回车之后，会先启动JVM，而JVM就是一个进程。
JVM在启动一个主线程，调用main方法。同时在启动一个垃圾回收线程负责看护，回收垃圾。
至少有两个线程并发：①垃圾回收线程 ②执行main方法的主线程
2.进程和线程什么关系？举个例子：
阿里巴巴：进程
马云：阿里巴巴的一个线程
董文红：阿里巴巴的一个线程
京东：进程
刘强东：京东的一个线程
张泽天：京东的一个线程
进程可以看做是现实生活当中的一个公司
线程可以看做是现实生活当中的某个员工
注意：进程A和进程B的内存独立不共享。（阿里巴巴和京东资源不会共享）
例：
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。
线程A和线程B呢？（有些共享，有些不共享）
在java语言当中呢，就是线程a和线程b，堆内存和方法区内存共享，但是栈内存独立，一个线程一个栈，互相不影响，都在进行各自的压栈弹栈。
假设启动10个线程，会有10个栈空间，每个栈之间互不干扰，各自执行各自的，这就是多线程并发。
例：
火车站：可以看做一个进程
火车站的每个售票窗口：可以看做是一个线程。
A在窗口1购票，B可以在窗口2购票，两个人不用等对方，所以并发可以提高效率。
多线程并发：
对于多核的CPU电脑来说，真正的多线程并发是没有问题的。
4核CPU表示同一时间点上，可以真正的有4个进程并发。
1.什么是真正的多线程并发？
t1线程执行t1.
t2线程执行t2.
t1不会影响t2，t2也不会印象t1.这叫做真正的多线程并发。
单核的cpu表示只有一个大脑：不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核cpu来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人的感觉是，多个事情同时在做。
线程A：魔兽游戏
线程B：酷狗音乐
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。
电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生的错觉，感觉是动画的。
看下面一段代码，分析一下，有几个线程？
/* * 分析一下以下代码有几个线程 * 1个线程，因为程序只有一个栈*/ public class ThreadTest01 { public static void main(String[] args) { System.out.println("main begin"); m1(); System.out.println("main over"); } private static void m1() { System.out.println("m1 begin"); m2(); System.out.println("m1 over"); } private static void m2() { System.out.println("m2 begin"); m3(); System.out.println("m2 over"); } private static void m3() { System.out.println("execute"); } }
java语言中实现线程的方式：
1.编写一个类，直接继承java.lang.Thread,重写run方法。
//定义线程类
public class MyThread extends Thread{
@Override
public void run(){
}
}
//创建线程对象
MyThread t = new MyThread();
//启动线程
t.start();
package thread; /*实现线程的第一种方式 编写一个类，直接结成java.lang.Thread,重写run方法。 怎么创建线程对象？new就行了 怎么启动线程呢？ 调用线程对象的start()方法。 * */ public class ThreadTest02 { public static void main(String[] args) { //这里是main方法，这里的代码属于主线程，在主栈中运行 //新建一个分支线程对象 MyThread t = new MyThread(); //启动线程 //t.run(); //如果直接调用run、而不用start，是不会启动线程，不会分配新的分支栈，这种方式就是单线程 /* start方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成吼瞬间就结束了 这段代码的任务只是为了开启一个新的栈空间，只要新的空间栈开出来，start()方法就结束，线程就启动成功 这段成功的线程会自动调用run方法，并且run方法在分支栈的底部（压栈）。 run方法在分支栈的底部，main方法在主栈的栈底部。run和main是平级的 */ t.start(); //这里的代码还是运行在主线程中 for (int i = 0;i<1000; i++){ System.out.println("主线程----》"+ i); } } } class MyThread extends Thread{ @Override public void run(){ //编写程序，这段程序运行在分支线程中（分支线） for (int i = 0;i<1000; i++){ System.out.println("分支线程----》"+ i); } } }
思考：如果调用run而不调用start方法会是什么样子？
package thread; /*实现线程的第一种方式 编写一个类，直接结成java.lang.Thread,重写run方法。 怎么创建线程对象？new就行了 怎么启动线程呢？ 调用线程对象的start()方法。 * */ public class ThreadTest02 { public static void main(String[] args) { //这里是main方法，这里的代码属于主线程，在主栈中运行 //新建一个分支线程对象 MyThread t = new MyThread(); t.run(); //如果直接调用run、而不用start，是不会启动线程，不会分配新的分支栈，这种方式就是单线程 //t.start(); //这里的代码还是运行在主线程中 for (int i = 0;i<1000; i++){ System.out.println("主线程----》"+ i); } } } class MyThread extends Thread{ @Override public void run(){ //编写程序，这段程序运行在分支线程中（分支线） for (int i = 0;i<1000; i++){ System.out.println("分支线程----》"+ i); } } }
结果是先执行完了run方法，输出了0-999之后，才运行了主方法里面的输出0-999.内存图如下：
2.第2种方式
编写一个类实现java.lang.Runnable接口
//定义一个可运行的类
class MyRunnable implements Runnable{
public void run() {
}
}
//创建线程对象
Thread t = new Thread(new MyRunnable());
//启动线程
t.start();
/* * 实现线程的第二种方式，编写一个类实现java.lang.Runnable接口*/ public class ThreadTest03 { public static void main(String[] args) { //1.创建一个可运行的对象 MyRunnable r = new MyRunnable(); //2.将可运行的对象封装成一个线程对象 Thread t = new Thread(r); /*1和2可以合并成下面一行代码*/ //Thread t = new Thread(new MyRunnable()); /*1和2也可以合并成匿名类写法如下，不需要写MyRunnable类*/ /* Thread t = new Thread(new Runnable() { public void run() { for (int i = 0;i<100; i++){ System.out.println("分支线程----》"+ i); } } }); * */ //启动线程 t.start(); for (int i = 0;i<100; i++){ System.out.println("主线程----》"+ i); } } } class MyRunnable implements Runnable{ public void run() { for (int i = 0;i<100; i++){ System.out.println("分支线程----》"+ i); } } }
线程的生命周期：
操作线程的名字：
/*
* 1.怎么获取当前线程对象？
* Thread t = Thread.currentThread();
* 返回t就是当前对象
* 2.获取线程对象的名字
* 线程对象.getName();
* 3.修改线程对象的名字
* 线程对象.setName("线程名字");
* 4.当线程没有设置名字的时候，默认的名字有什么规律？
* Thread-0
* Thread-1
* Thread-2
* Thread-3
* */
public class ThreadTest04 { public static void main(String[] args) { //currentThread就是当前线程对象 /*这个代码出现在main方法当中，所以当前线程就是主线程*/ System.out.println(Thread.currentThread()); //创建一个线程对象 MyThread4 t = new MyThread4(); //设置线程的名字 t.setName("T1"); //获取线程的名字 System.out.println(t.getName()); MyThread4 t1 = new MyThread4(); t1.setName("T2"); System.out.println(t1.getName()); //启动线程 t1.start(); t.start(); } } class MyThread4 extends Thread{ @Override public void run() { //编写程序，这段程序运行在分支线程中（分支线） //currentThread()就是当前线程对象，当前线程是谁呢？ /*那个线程启动，一旦运行到方法，就是那个线程 当t1线程执行run方法，那么这个线程就是t1 当t2线程执行run方法，那么这个线程就是t2 * */ for (int i = 0;i<10; i++){ //System.out.println("分支线程----》"+ i); System.out.println(Thread.currentThread().getName() + "---" + i); } } }
/*
关于线程的sleep方法：
static void sleep(long millis)
1、静态方法
2、参数是毫秒
3、作用：让当前线程进入休眠状态，进入‘阻塞状态’，放弃占有CPU时间片，让给其他线程使用
这行代码出现在A线程中，A线程就会进入休眠
这行代码出现在B线程中，B线程就会进入休眠
4、Thread.sleep()方法，可以做到，间隔特定的时间，去执行特定的代码，每隔多久执行一次
*/
public class ThreadTest05 { public static void main(String[] args) { //让当前线程进入休眠，睡眠5秒,当前线程是主线程！！！ try { Thread.sleep(1000*5); } catch (InterruptedException e) { e.printStackTrace(); } //5秒之后出现该代码 System.out.println("Hello world"); for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+"---->"+i); //睡眠一秒 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
叫醒线程的方法：用Thread.interrupt()方法
/*
一个线程sleep睡眠太久了，如果希望半道上醒来，应该怎么做？也就是说怎么侥幸一个正在睡眠的线程？？
注意：这个不是终断线程的执行，而是终止线程的睡眠
*/
public class ThreadTest06 { public static void main(String[] args) { Thread t = new Thread(new MyRunnable6()); t.setName("t"); t.start(); //希望5s之后，t线程醒来(5s之后，手里的活干完了) try { Thread.sleep(1000 * 5); } catch (InterruptedException e) { //打印异常的信息 e.printStackTrace(); } //中断t线程的睡眠（这种中断睡眠的方式，依靠的是java的异常处理机制） t.interrupt(); //干扰，一盆冷水过去 } } class MyRunnable6 implements Runnable{ /**重点：run(）当中的异常不能throws，只能try catch。 * 因为run方法在父类中没有抛出任何的异常，子类不能比父类抛出更多的异常 * */ public void run() { //休眠一年 System.out.println(Thread.currentThread().getName()+ "---->" + "begin"); try { Thread.sleep(1000 * 60 * 60 * 24 * 365); } catch (InterruptedException e) { //打印异常的信息,也可以不打印出来，直接注释掉 e.printStackTrace(); } //一年之后才可以执行这里 System.out.println(Thread.currentThread().getName()+ "---->" + "end"); } }
