黑马程序员java学习笔记，多线程

多线程

线程时进程中一个独立的控制单元，线程在控制着进程的执行。

一个进程至少有一个线程

JVM启动的时候会有一个进程java.exe

该进程中至少一个线程负责java程序的执行

而且这个线程运行的代码存在于main方法中，为主线程

class ThreadDemo extends Thread {

 public void run(){

  

 }

}

继承一个Thread类：1.定义类继承Thread类2.复写run方法3.调用start()方法

ThreadDemo d=new ThreadDemo();

d.start();//开启线程并执行该线程的run方法

每次运行结果都不是一样的，因为多个线程都获取cpu的执行权，互相抢夺cpu资源。

Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该代码就是run方法

wait(),notify(),sleep(time),stop()

Thread.currentThread().getName();当前线程

/*

卖票程序，多个窗口都能卖票

**/

class TicketSell extends Thread{

 private static int tick=100;//使用静态

 public void run(){

  while(true){

  if(tick>0){

   System.out.println(Thread.currentThread().getName()+"sale"+tick--);

  }

  }

 }

}

class TicketDemo{

 public static void main(String[] args){

  TicketSell t1=new TicketSell();

  TicketSell t2=new TicketSell();

  TicketSell t3=new TicketSell();

  TicketSell t4=new TicketSell();

  t1.start();

  t2.start();

  t3.start();

  t4.start();

 }

}

---------------------------------------------------------

1.定义实现Runnable接口

2.覆盖run方法

3.通过Thread类建立线程对象

4.将Runnable接口的子类作为对象传给Thread类的构造函数

5.调用Thread类的start方法开启线程并调用Runnable接口

class TicketSell implements Runnable{//extends Thread{

 private static int tick=100;//使用静态

 Object obj=new Object();

 public void run(){

  while(true)

  {

   Synchronized(obj){

  if(tick>0){

   System.out.println(Thread.currentThread().getName()+"sale"+tick--);

  }

  }

  }

 }

}

class TicketDemo{

 public void main(String[] args){

  TicketSell s=new TicketSell();

  Thread t=new Thread(s);

  t.start();

 }

}

多线程的安全问题

   当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，另一个线程参与进来执行

导致共享数据的错误。

   同步代码块

    synchronized(对象){

  需要被同步的代码；

 }

同步函数,sychronized修饰符修饰函数 就可以了

同步函数使用的锁匙this

静态同步函数使用的锁不是this，因为静态方法中不可以定义this

静态进内存是，内存中没有本类对象，但是一定有类对应的字节码文件对象

类名.class 该对象的类型是class

单例设计模式，懒汉式

1.   class Single{

  private Single(){}

  public static Single s=null;

  public static synchronized Single getInstance(){

   if (s==null)

    s=new Single();

  } 

 }

2.     class Single{

  private Single(){}

  public static Single s=null;

  public static  Single getInstance(){

     synchronized(Single.class){

     if (s==null)

    s=new Single();

    }

  } 

 }

3.更高效的方法

              class Single{

  private Single(){}

  public static Single s=null;

  public static  Single getInstance(){

   if(s==null){

   synchronized(Single.class){

     if (s==null)

    s=new Single();

    }

   }  

  } 

 }

死锁：同步中嵌套同步，但是锁却不同

进程间的通信：多个线程在操作同一个资源，但是操作的动作不同

 

等待唤醒机制

notifyAll();wait();notify();必须都要使用在同步中

用synchronized中的对象来标记