Java基础复习（十一）多线程（主线程，垃圾回收器，synchronize关键字，同步代码块，同步函数）

Java基础复习（十一）多线程

• 多线程:
• 程序:一个可执行的文件
• 进程:一个正在运行的程序.也可以理解成在内存中开辟了一块儿空间
• 线程:负责程序的运行,可以看做一条执行的通道或执行单元,所以我们通常将进程的工作理解成线程的工作
• 进程中可不可以没有线程? 必须有线程,至少有一个.当有一个线程的时候我们称为单线程(唯一的线程就是主线程).
• 当有一个以上的线程同时存在的时候我们称为多线程.
• 多线程的作用:为了实现同一时间干多件事情.
• 任务区:我们将线程工作的地方称为任务区.
• 每一个线程都有一个任务区,任务区通过对应的方法产生作用.
• JVM默认是多线程吗?
• 至少要有两个线程:
• 主线程:任务区:main函数
• 垃圾回收线程:任务区:finalize函数

主线程

public static void main(String[] args) 

垃圾回收器

• 原理:当执行gc时,会触发垃圾回收机制,开启垃圾回收线程,执行finalize方法（由系统调用）
• cpu的特性:多个线程之间是抢cpu的关系cpu有随机性
• 默认情况下,主线程和垃圾回收线程都是由系统创建的,但是我们需要完成自己的功能----创建自己的线程对象

java将线程面向对象了,形成的类就是Thread,在Thread类内部执行任务的方法叫run()

注意:如果想让run作为任务区,必须让他去被自动调用.我们通过执行start()方法,来开启线程,继而实现run方法的自动调用.

主线程的名字:main 子线程的名字:从Thread-0开始命名

public class Demo11 {
	public static void main(String[] args) {
		//创建自己的线程对象
		//使用子类创建对象
		MyThread t0 = new MyThread("t0");
		MyThread t1 = new MyThread("t1");
		t0.start();//开启线程
		t1.start();//开启线程
		
		//当我们手动调用run的时候,他失去了任务区的功能,变成了一个普通的方法.
		//当run作为一个普通方法时,内部对应的线程跟调用他的位置保持一致.
//		t0.run();
//		t1.run();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("  main   "+Thread.currentThread().getName()+"   i:"+i);//有三个线程(暂时忽略垃圾回收线程)
		}
	}
}

class MyThread extends Thread{
	String name1;
	//重写run方法,实现我们的功能.run就是我们的任务区
	/*
	 * Thread.currentThread():获取的是当前的线程
	 * Thread.currentThread().getName():线程的名字
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(this.name1+"  MyThread   "+Thread.currentThread().getName()+"   i:"+i);
		}
	}
	public MyThread(String name1) {
		this.name1 = name1;
	}
}

代码实例：

实现四个售票员售票，考虑线程安全

1. 使用同步代码块Synchronized（锁（对象））{}

2. 对作为锁的对象的要求

   1. 必须是对象
   2. 必须保证被多个线程共享
   3. 可以充当锁的:1.一个普通的对象 2.当前对象的引用–this 3.类的字节码文件

3. 同步代码块儿的特点:1.可以保证线程的安全 2.由于每次都要进行判断处理,所以降低了执行效率

4. package test;
   
   public class demo3 {
       public static void main(String[] args) {
           Ticket ticket = new Ticket();
           //将任务与线程绑定
           Thread t0 = new Thread(ticket);
           Thread t1 = new Thread(ticket);
           Thread t2 = new Thread(ticket);
           Thread t3 = new Thread(ticket);
           //开启线程
           t0.start();
           t1.start();
           t2.start();
           t3.start();
       }
   }
   
   class Ticket implements Runnable{
   
       int sum = 20;
       boolean flag = true;
       //让Object类型的对象临时充当锁
       Object object = new Object();
       @Override
       public void run() {
           while (flag)
           {
               //让当前的线程睡100毫秒
               //作用:让他暂时让出cpu
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
   
               /*
                * 锁的条件:
                * 1.锁必须是对象      普通的对象/this/字节码文件
                * 2.要被所有的线程共享
                *
                * 注意:字节码文件的使用范围太大,一般不建议使用.
                */
               synchronized (object)
               {
                   if (sum > 0){
                       System.out.println("剩余 票数:"+ --sum);
                   }
                   else {
                       flag = !flag;
                   }
               }
           }
       }
   }
   
   

比较同步代码块儿和同步函数

1. 同步代码块儿使用更加的灵活,只给需要同步的部分代码同步即可,而同步函数是给这个函数内的所有代码同步.
2. 由于处于同步的代码越少越好,所以最好使用同步代码块儿
3. 当在一个类中同时存在多个synchronized修饰的代码块儿或函数时，要想安全，就必须让他们后面的对象一致。因为只有同一把锁才能安全。
4. 同步函数的锁：this
5. 静态同步函数在进内存的时候不会创建对象，但是存在其所属类的字节码文件对象，属于class类型的对象，所以静态同步函数的锁是其所属类的字节码文件对象

synchronized

1. 是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2. 是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
3. 除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/区块/}，它的作用域是当前对象；
4. synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

代码实例2：

两个人同时向银行同一个账户存钱。（两个人，一份数据）

package test;

public class demo5 {
    public static void main(String[] args) {

        SaveMoney saveMoney = new SaveMoney();

        Thread t0 = new Thread(saveMoney);
        Thread t1 = new Thread(saveMoney);

        t0.start();
        t1.start();

    }
}

class Bank{
    int money;

    //使用同步代码块
    public void addMoney(int money)
    {
        synchronized (Bank.class){
            this.money+=money;
            System.out.println(this.money);
        }
    }

    //使用同步函数
    //非静态的同步函数
    //在synchronized后面默认有一个this
   /* public synchronized void addMoney(int money)
    {
        this.money+=money;
        System.out.println(this.money);
    }*/
    //静态的同步函数
    //在synchronized后面默认有一个当前类的字节码文件-----Bank.class
    /*public synchronized static void addMoney(int money) {
        this.money += money;
        System.out.println(this.money);
    }*/
}

class SaveMoney implements Runnable{

    Bank bank = new Bank();
    @Override
    public void run() {
        for (int i = 0; i < 3; i++)
        {
            bank.addMoney(100);
        }

    }
}