多线程

1.多线程介绍
进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过


程中的程序，并且具有一定独立功能。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中


是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
什么是多线程呢？即就是一个程序中有多个线程在同时执行。
单线程：cpu执行一个线程
多线程：cpu在多个线程中随机切换
2.主线程
 *main方法其实就是一个线程:所以main方法顺序执行
 *main方法所在的线程叫 主线程
 */
public class Demo01 {
public static void main(String[] args) {
       System.out.println(1/0);
}
}


3.Thread类
常用方法：start();使该线程开始执行；Java虚拟机调用该线程的run()方法
run();该线程要执行的操作
sleep(long millis)在指定的毫秒内让指定的线程休眠


创建新执行线程有两种方法。
一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run


方法相当于其他线程的main方法。
另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象


，传入到某个线程的构造方法中，开启线程。


4.创建线程方式一继承Thread类


创建线程的步骤：
1 定义一个类继承Thread。
2 重写run方法。
3 创建子类对象，就是创建线程对象。
4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。


public class ThreadDemo01 extends Thread{
    @Override
    public void run() {
       for(int i=0;i<10;i++){
      System.out.println("run..."+i);
       }
    }
}
public class Demo02 {
public static void main(String[] args) {
       ThreadDemo01 td=new ThreadDemo01();
       //td.run();//不会开启任何自定义线程,这句话仅仅相当于创建对象调用方法
       td.start();
       
       for(int i=0;i<10;i++){
      System.out.println("main..."+i);
       }
}


继承Thread类原理：
继承Thread类：因为Thread类用来描述线程，具备线程应该有功能
创建线程的目的：是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建


并执行需要给定线程要执行的任务。
Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线


程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方


法动作。


5.Thread类的方法
开启的线程都会有自己的独立运行栈内存
currentThread();返回对当前正在执行的线程对象的引用。
getName();返回该对象的名称




class MyThread extends Thread {  //继承Thread
MyThread(String name){
super(name);
}
//复写其中的run方法
public void run(){
for (int i=1;i<=20 ;i++ ){
System.out.println(Thread.currentThread().getName()+",i="+i);
}
}
}


public static void main(String[] args) {
//创建两个线程任务
MyThread d = new MyThread();
MyThread d2 = new MyThread();
d.run();//没有开启新线程, 在主线程调用run方法
d2.start();//开启一个新线程，新线程调用run方法
}


进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。


6.创建线程方式—实现Runnable接口
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类


对象，传入到某个线程的构造方法中，开启线程。Runnable接口用来指定每个线程要执行的任务。包含了一个 


run 的无参数抽象方法，需要由接口实现类重写该方法。


第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合


面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在


一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独


分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。




thread类构造方法
Thread（Runnable target） target作为其运行对象
Thread（Runnable target，String name） target作为其运行对象，name作为名称


创建线程的步骤。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。


public class Demo02 {
public static void main(String[] args) {
//创建线程执行目标类对象
Runnable runn = new MyRunnable();
//将Runnable接口的子类对象作为参数传递给Thread类的构造函数
Thread thread = new Thread(runn);
Thread thread2 = new Thread(runn);
//开启线程
thread.start();
thread2.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程：正在执行！"+i);
}
}
}
自定义线程执行任务类
public class MyRunnable implements Runnable{


//定义线程要执行的run方法逻辑
@Override
public void run() {

for (int i = 0; i < 10; i++) {
System.out.println("我的线程：正在执行！"+i);
}
}
}


7.实现Runnable的原理
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码


定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方


法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函


数，这样，线程对象创建时就可以明确要运行的线程的任务。
8.线程的匿名内部类使用
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
方式1：创建线程对象时，直接重写Thread类中的run方法
new Thread() {
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
+ "...X...." + x);
}
}
}.start();


方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法
Runnable r = new Runnable() {
public void run() {
for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName()
+ "...Y...." + x);
}
}
};
new Thread(r).start();











9.线程并发同步概念


线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合，“同步”就是协同步调昨，也就是按


照预定的先后顺序进行运行，即“你先，我等， 你做完，我再做”。


线程同步，就是当线程发出一个功能调用时，在没有得到结果之前，该调用就不会返回，其他线程也不能调用


该方法。


就一般而言，我们在说同步、异步的时候，特指那些需要其他组件来配合或者需要一定时间来完成的任务。在


多线程编程里面，一些较为敏感的数据时不允许被多个线程同时访问的，使用线程同步技术，确保数据在任何


时刻最多只有一个线程访问，保证数据的完整性。