java基础学习13（线程、线程安全问题、synchronized）

进程与线程的定义

进程：指在系统中能独立运行并作为资源分配的基本单位，它是由一组机器指令、数据和堆栈等组成的，是一个能独立运行的活动实体。
线程：线程是进程中的一个实体，作为系统调度和分派的基本单位。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

在java中会有线程负责执行代码，jvm在运行的时候都会创建一个main线程执行main方法中所有代码

什么是多线程

单线程程序：即若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。

多线程程序：即若有多个任务可以同时执行

多线程的好处：

• 提高了资源的利用率。

多线程 的弊端：

• 增加cpu的负担。
• 存在线程安全问题与死锁现象。

java中如何创建多线程

方式一

• 自定义类A继承Thread
• 重写run函数
• 建立A对象并调用start()函数

明确调用start函数与直接调用run函数的区别？
线程一旦开启就会执行run函数，如果直接调用run函数就只是单纯的调用并不是线程被开启。

class A extends Thread{
    @Override
    public void run() {
        System.out.println("跑起来");
    }
}


public class Test {

        public static void main(String[] args) throws Exception {
            A a = new A();
            a.start();
        }

方式二

• 创建类A实现Runnable接口
• 建立Thread对象时并将A对象的示例作为参数传入
• Thread对象调用start函数

class A implements Runnable{
    public void run() {
        System.out.println("跑起来");
    }
}


public class Test {

        public static void main(String[] args) throws Exception {
            new Thread(new A()).start();
        }
}        

注意:
线程中的run函数中只能捕获异常，并不能抛出异常，因为函数重写时抛出的异常必须小于等于父类的异常

线程的声明周期

Thread中常用的函数

setName(String name) 改变线程名称，使之与参数 name 相同。
setPriority(int newPriority) 更改线程的优先级。
getName() 返回该线程的名称。
getPriority() 返回线程的优先级。
sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

注意:

• 线程默认的优先级是5，在设置时优先级的值必须在1～10之间不然会报错，理论情况下优先级越高该线程被执行的概率越大
• Thread.currentThread() 返回对当前正在执行的线程对象的引用

class A extends Thread{
    @Override
    public void run() {
        System.out.println(this);//Thread[线程一,1,main]
        System.out.println("当前线程对象：" + Thread.currentThread());//当前线程对象：Thread[线程一,1,main]
        for (int i = 0; i<100; i++){
            System.out.println(this.getName()+""+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread.currentThread();
        }
    }
}

public class Test {
    public static void main(String[] args)  {
        A a = new A();
        a.setName("线程一");
        System.out.println(a.getName());//线程一

        a.setPriority(1);
        System.out.println(a.getPriority());//1

        a.start();
    }
}    

线程安全问题

什么是线程安全问题呢？
我们知道多线程的执行其实就是cpu的资源争夺大战，那么那边就会出现有的时候代码没有执行完这个线程的执行权就被别的线程抢走了，所以会出现问题。总的来说出现该问题的前提就是，多个线程对一个共享资源进行多步操作时就会出现线程安全问题。

解决办法
方式一：
synchronized(“锁”){
}

方式二：
同步函数

class Window extends Thread{
    public static int number = 100;

    @Override
    public  void run() {
        while (true){
            synchronized ("锁"){
                if (number > 0){
                    System.out.println(Thread.currentThread().getName()+"出售车票"+number);
                    number--;
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    System.out.println(Thread.currentThread().getName()+"提示您:没有票啦～");
                    break;
                }
            }
        }
    }

    Window(String name){
        super(name);
    }

}

public class Test {

    public static void main(String[] args)  {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");

        w1.start();
        w2.start();

    }
 }   

同步代码块注意

1. 只有在线程安全问题存在的情况下才用synchronized，因为本身synchronized就会降低效率。
2. synchronized中的锁可以是任意对象，但是该对象必须被所有线程所共用。
3. 在同步代码快中sleep并不会释放锁

同步函数注意

1. 静态函数用synchronized修饰时锁是当前类的字节码文件。非静态函数用synchronized修饰时锁是this
2. synchronized修饰函数时锁是指定的。