关于多线程的学习理解笔记

**第一：**理解什么是线程 ，什么是进程？
进程：是资源分配的最小单元，进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是操作系统进行资源分配和调度的一个独立单位（简单说就像笔记本电脑中的某软件在内存中的执行过程，打开任务管理器，就可以看到其在内存中执行的过程）
线程：就是进程的一个实体，是比进程更小的能独立运行的基本单位
二者联系：一个进程可以有多个线程，线程是共享进程资源的

**第二：**实现多线程的两种方式：
（1）继承Thread类

class ThreadA extends Thread {
 public void run(){
  
  for  (int i = 0; i < 100; i++)
  {
   System.out.println(i);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
   
    e.printStackTrace();
   }
  }
 }
}

public class demo01 {
 public static void main(String[] args) {
  Thread a = new ThreadA();
  a.start();
 }
}

（2）实现Runnable接口
定义一个runnable接口 覆盖接口中的run方法，
将线程的任务代码封装到run方法中去
通过Thread类创建线程对象，并将Runnable接口的子类对象作为构造函数的参数进行传递
调用线程的start方法

 class Demo implements Runnable{
 
 public void run (){
  for (int i = 0; i < 10;i++)
  {
   System.out.println(i);
   try {
    Thread.sleep(500);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
}
public class demo02 {
 public static void main(String[] args) {
  Demo d = new Demo();//将runnable 接口的子类对象作为构造方法的参数进行传递
  
  Thread t1 = new Thread(d);//创建Thread 实例化，把子类参数传递进去
  Thread t2 = new Thread(d);
  t1.start();
  t2.start();
 }
}

第三：
Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别?
sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

四：**
线程同步机制 为了解决线程安全问题，java主要推出了线程同步 比如说：一个人上洗手间时，他进入洗手间后会将门关闭，等出来时再将门锁打开，然后其他人才可以进入
（1）使用同步代码块

    static class tickets implements Runnable {

        int num = 100;


        public void run() {
            while (true) {
                synchronized (this) {
                    if (num > 0) {
                        System.out.println("票数:" + num--);
                    }
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
    class demo05 {
        public static void main(String[] args) {
            test04.tickets t = new test04.tickets();
            Thread t1 = new Thread(t);
            Thread t2 = new Thread(t);
            Thread t3 = new Thread(t);
            Thread t4 = new Thread(t);

            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
}

（2）使用同步方法

class cus implements Runnable{

    bank b= new bank();
    public void run() {

        b.save(100);
    }
}

class bank {
    int sum ;
    public synchronized void save (int num ){
        for (int i =0 ; i < 3; i++){
            sum = num + sum;
            System.out.println("存的钱为：" + sum);
        }
    }
}
public class test05 {
    public static void main(String[] args) {
        cus c = new cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();

    }
}