多线程

一：
进程：是一个正在执行中的程序

    每一个进程之星都有一个执行顺序，该顺序是一个执行路径或者叫一个控制单元

 线程：就是进程中一个独立的控制单元

    线程控制着进程的执行


一个进程中至少有一个线程
java VM  启动的时候会有一个进程java.exe


该进程中至少一个线程负责java程序的执行
而且这个线程的代码存在于main方法中。
      该线程称之为主线程


 扩展：
 其实jvm启动不止一个线程

二：如何在自定义的代码中，自定义一个线程
  Thread类

  第一种方式：继承Thread

  步骤：
  1,定义类继承Thread
  2，复写Thread中的run方法
  目的：将自定义的代码存储在run方法中，让线程运行
  3，调用线程的start方法
   作用：
   启动线程，调用run方法

发现运行结果每一次都不同

因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行
明确一点，在某一时刻，只能有一个程序在执行（多核除外）
cpu在作着快速的切换，已达到看上去是同时执行的效果
我们可以形象的把多线程的运行行为看成是在抢夺cpu的执行权
这就是多线程的一个特性：随机性。


为什么覆盖run方法？
 Thread用于描述线程
 该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法
 也就是说Thread类中的run方法，用于存储线程要运行的代码


线程都与自己默认的名称，该名称从Thread-0开始
static Thread cureentThread();获取当前线程对象
getName（）：获取线程名称
设置线程名称：setName或者构造函数


 第二种方式：
   
   步骤：
   1，定义类实现Runnable接口
   2，覆盖Runnable接口中的run方法
   将线程要运行的代码存放在run方法中
   3，通过Thread类建立线程对象
   4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法
   为什么要将Runable接口的子类对象传递给Thread的构造方法
   因为，自定义的run方法所属的对象是Runnable接口的子类对象
   所以要让线程去指定指定对象的run方法，就必须明确该run方法所述的对象
  5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

实现方式和继承方式的区别：
 实现方式好处：避免了单线程的局限性， 在定义线城时，建议使用实现方式

 继承Thread类：线程代码存放在Thread子类run方法中
 实现Runnable，线程的代码存放在揭露的子类的run方法中

 三：多线程安全问题：
 问题的原因：
 当多条语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
 另一个线程参与进来执行，导致共享数据的错误
解决办法：
 对多条操作共享数据的语句，只能让一个县城都执行完，在执行过程中，
  其他线程不可以参与执行
java对于多线程的安全问题提供了专门的解决方式：
1，同步代码块，
格式：
synchronized（对象）{
需要被同步的代码
}

在操作共享数据的代码需要被同步

对象如同锁，持有锁的线程可以再同步中执行
没有持有锁的线程即使持有cpu的执行权也进不去

同步的前提：

A，必须要有两个以上的线程
B，必须是多个线程使用同一个锁

好处：解决多线程的安全问题
弊端：消耗了资源

如何找问题？
a，明确哪些代码是多线程运行代码
b，明确共享数据
c，明确多线程代码中那些是操作共享数据的。

同步同事操作共享数据的多条语句

,2，同步函数：

函数具备同步性用synchronized修饰函数

同步函数用的是哪个锁？
函数需要被对象调用，那么函数都有一个所属对象的引用
那么同步函数用的是this

如果同步函数被静态修饰后用的锁是什么？
不是this因为静态方法中不能定义this
静态进内存时，内存中没有本类没对象但是一定有该类的字节码文件对象，
类名.class该对象的类型是Class

静态的同步方法使用的锁是该方法所在类的字节码文件对象：类名.class

死锁问题：

同步中嵌套同步，锁却不同

/*
死锁程序
*/
class test implements Runnable
{
private boolean flag;
test(boolean flag)
{
this.flag = flag;
}
    public void run()
{
if(flag)
{

synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
else
{


synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}

}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class deadLockTest
{
public static void main(String[] args) 
{
Thread t1 = new Thread(new test(true));
Thread t2 = new Thread(new test(false));
t1.start();
t2.start();
}
}