JAVA随笔-多线程

实现多线程

1.理解

• 进程：是正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源
• 线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序

2.实现方式

2.1 实现方式1：继承Thread类

// 具体线程类
public class MyThread extends Thread {
	@Override
	public void run() {
		for(int i=0; i<100; i++) {
		System.out.println(i);
		}
	}
}
//主程序
public class MyThreadDemo {
	public static void main(String[] args) {
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		my1.start();
		my2.start();
	}
}

• 两个小问题
  • 为什么要重写run()方法？
    因为run()是用来封装被线程执行的代码
  • run()方法和start()方法的区别？
    run()：封装线程执行的代码，直接调用，相当于普通方法的调用
    start()：启动线程；然后由JVM调用此线程的run()方法

2.2 Runnable实现

// 线程类
public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for(int i=0; i<100; i++) {
		System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

//主程序
public class MyRunnableDemo {
	public static void main(String[] args) {
		//创建MyRunnable类的对象
		MyRunnable my = new MyRunnable();
		//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
		// Thread t1 = new Thread(my);
		//这种构造方法可将线程名称直接传入
		Thread t1 = new Thread(my,"飞机");
		//启动线程
		t1.start();
	}
}

3 线程名称

• 获得线程名称
  • getName():Thread实现
  • System.out.println(Thread.currentThread().getName())：Runnable实现

3.1 Thread实现

//运用带参构造方法创造线程，需要在线程类构造方法中super
//因为带参传入线程名称构造方法存在于父类
public class MyThread extends Thread {
	public MyThread() {}
	public MyThread(String name) {
		super(name);
	}
}
------------------------------------------------------------
//获取当前运行的线程名称
System.out.println(Thread.currentThread().getName());

3.2 Runnable实现（如上）

4 线程优先级

• 线程调度
  • 两种调度方式
    • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
    • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
  • Java使用抢占式
  • 随机性
    • 假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的
    • 可以通过设置线程优先级来增到线程获取CPU的概率，但不是绝对可以获得CPU，它只是概率增大。

5.线程控制

• join():等待这个线程死亡
• setDaemon(Boolean)：将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

//假设有3个线程，t1,t2为守护线程，当t3执行结束后，t1,t2也会结束，
//其任务未执行完毕
  public static void main(String[] args) {
        MyThread t1 = new MyThread("11");
        MyThread t2 = new MyThread("22");
        MyThread t3 = new MyThread("33");

        t1.setDaemon(true);
        t2.setDaemon(true);
        t1.start();
        t2.start();
        t3.start();
}

6 线程生命周期

• 注意阻塞必须先达到就绪，才能运行

线程同步

1.三个窗口卖票的简单应用（不合理）

// 线程卖票类
public class SellTicket implements Runnable{
    private int tickets = 100;
    @Override
    public void run() {
        while(true){
                if(tickets > 0 ){
                    System.out.println(Thread.currentThread().getName()+"出售:" + tickets);
                    tickets--;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
        }
    }
}

//主程序
public class SellTicketTest {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();

        Thread t1 = new Thread(sellTicket,"第一");
        Thread t2 = new Thread(sellTicket,"第二");
        Thread t3 = new Thread(sellTicket,"第三");

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

• 从结果可观察到，三个窗口会卖了同样的票，且最终票数会成为负数

2.同步代码块的应用

• 安全问题出现的条件

  • 是多线程环境
  • 有共享数据
  • 有多条语句操作共享数据

• 解决多线程安全问题

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  • Java提供了同步代码块的方式来解决

• 同步代码块格式

  synchronized(任意对象) {
  多条语句操作共享数据的代码
  }

  synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁。

• 同步的好处和弊端

  • 好处：解决了多线程的数据安全问题
  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的
    运行效率

// 同步代码块加锁
public class SellTicket implements Runnable{
    private int tickets = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (obj){
                if(tickets > 0 ){
                    System.out.println(Thread.currentThread().getName()+"出售:" + tickets);
                    tickets--;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
}

3. 同步方法的应用

• 格式

  修饰符 synchronized 返回值类型 方法名(方法参数) {
  方法体；
  }

• 同步方法的锁对象是什么呢?
  this
• 静态同步方法

修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体；
}

• 同步静态方法的锁对象是什么呢?
  类名.class

4.线程安全的类

• StringBuffer
  • 线程安全，可变的字符序列
  • 从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
• Vector
  • 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector
• Hashtable
  • 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
  • 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable。
• 可以通过相应的实现来看源码，可以发现线程安全的类，中会有synchronized 关键字。