黑马程序员—Java多线程

------- android培训、java培训、期待与您交流！ ----------

 

 

 

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫控制单元。

 

线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。

 

 java vm启动的时候会有一个进程，叫做java.exe该进程中至少有一个线程在负责java程序的执行，而且这个线程

运行的代码存在于main方法中。该线程称为主线程。

 

扩展：其实仔细来说jvm启动不止一个线程，还有负责垃圾回收的线程。

 

1.如何在自定义的代码中，自定义一个线程呢?

 我们通过对Api查找，java已经提供了对这类事物的描述。

 第一种方式：继承Thread类。

步骤：1.定义类继承Thread类。

           2.复写Thread类里面的run（）方法。

              目的：将自定义代码存储在run（）方法中。让线程运行代码。

           3.调用线程的start()方法。该方法有两个作用。1.启动线程。2.调用该线程的run（）方法。

代码示例：

//定义Demo类继承Threadclass Demo extends Thread{//复写run方法，run方法里面为线程要运行的代码public void run(){for (int i = 0; i < 50; i++)    System.out.println("Demo run"+i);}}//测试线程类public class ThreadDemo{public static void main(String[] args){Demo d = new Demo(); //这就创建好了一个线程。d.start();//开启线程并执行该线程里面的run（）方法。d.run();//仅仅是调用对象的方法，线程虽然创建了，但是并没有开启。for (int i = 0; i < 50; i++)System.out.println("main run"+i);}}

 

对于上面的代码，发现运行结果每一次都不一样，因为多个线程都在获取cpu的执行权，cpu执行到谁就执行谁。
 明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）
  cpu在做着快速的切换，以达到看上去像是同时运行的效果。
 我们可以形象的把多线程的运行形容为在互相抢夺cpu的执行权。

 
 这就是多线程的一个特性：随机性、谁抢到谁执行，至于执行多长时间，cpu说了算。
 
为什么要重写Thread的run（）方法呢？
 Thread类用于描述线程，该类定义了一个功能就是存储了线程要运行的代码。该存储方法就是run（）方法。
 Thread类中的run（）方法是用来存储线程要运行的代码。

 

 

 

创建线程的第二种方式：实现Runnable接口，重写run（）方法。
   1.定义类，实现Runnable接口。
   2.重写Runnable接口中的run（）方法。
      将线程要实现的代码存放在该run（）方法中。
     
   3.通过Thread类创建线程对象。
   4.将Runnable接口的实现类作为实际参数传递给Thread类的构造函数。
     为什么要将Runnable的实现类的对象传递给Thread类的构造函数呢？
     因为自定义的run（）方法所属的对象是Runnable实现类的对象。
     所以要让线程去指定指定对象的run（）方法。就必须明确该run（）方法所属的对象。
    
   5.调用Thread类的start()方法开启线程并调用Runnable接口实现类的run（）方法。

代码示例：

//创建Demo类实现Runnable接口class Demo implements Runnable{//重写run方法，封装线程要运行的代码public void run() {for (int i = 0; i < 50; i++)System.out.println("Demo run"+i);}}//测试线程类public class ThreadDemo{public static void main(String[] args){//创建Runnable类的子类对象Demo demo = new Demo();//将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数Thread th = new Thread(demo);//Thread类对象调用start方法开启线程th.start();}}

实现方式和继承方式有什么区别呢？
 *  避免了单继承的局限性。在定义线程时，建议使用实现Runnable式。开发中都用。
 *  两种方式线程代码存放的位置不一样。
 *  继承Thread：线程代码存放在Thread类的子类的run（）方法中。
 *  实现Runnable：线程代码存放在Runnable接口实现类的run（）方法中。

 

为什么要有Runnable接口的出现？

1：通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。

因为实现Runnable接口可以避免单继承的局限性。

 

2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

 

实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

 

多线程安全问题：

发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

 

涉及到两个因素：

1，多个线程在操作共享数据。

2，有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

 

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

 

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。

格式：

synchronized(对象) {  // 任意对象都可以。这个对象就是锁。

   需要被同步的代码；

}

 

同步：

好处：解决了线程安全问题。

弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

 

定义同步是有前提的：

1，必须要有两个或者两个以上的线程，才需要同步。

2，多个线程必须保证使用的是同一个锁。

 

同步的第二种表现形式：

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

 

同步函数是用的哪个锁呢？

通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。

 

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class

 

同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

 

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

 

------- android培训、java培训、期待与您交流！ ----------