Java基础学习(八) – 多线程
- 2019 年 10 月 13 日
- 笔记
理解线程
进程是指一个内存中运行的应用程序，系统运行一个程序即是一个进程从创建，运行，结束的过程。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。
多线程的特点是并发执行（同一时间段执行多个任务），实际上并不能提高程序运行速度，但能够提高运行效率，让cpu使用率更高。
关于线程调度，分为分时调度和抢占调度。
- 抢占调度模式，需要设置线程的优先级，优先级别高的线程优先使用cpu。
- 分时调度，所有线程轮流使用cpu，平均分配每个线程占用cpu的时间。
1.Java中的多线程实现
Java中实现多线程有两种方式：
- 继承Thread类并重写run方法，创建Thread对象执行。
- 定义Runable接口的实现类，并重写接口的run方法（线程执行体）。Runnable实现类里包含的run()方法仅作为线程执行体，然后传递给Thread对象执行。
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
构造方法：
- public Thread() :分配一个新的线程对象。
- public Thread(String name) :分配一个指定名字的新的线程对象。
- public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
- public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法：
- public String getName() :获取当前线程名称。
- public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
- public void run() :此线程要执行的任务在此处定义代码。
- public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
- public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
下面通过代码来了解执行过程：
//继承Thead实现 class MyThead extends Thread{ public MyThead(String name){ super(name); } @Override public void run(){ System.out.println("我是线程"+getName()); } } public class TestThread { public static void main(String[] args){ //创建线程对象 MyThead mt = new MyThead("M"); //开启一个新的线程 mt.start(); System.out.println("我是main线程"); } }
//实现Runnable，重写run方法 class MyRunable implements Runnable{ @Override public void run(){ System.out.println("我是线程"+ Thread.currentThread().getName()); } } public class TestRunable { public static void main(String[] args){ //创建 MyRunable对象 MyRunable mr = new MyRunable(); //创建线程对象 Thread t = new Thread(mr,"t"); //运行线程 t.start(); System.out.println("我是main线程"); } }
2.线程同步
使用多个线程访问同一资源的时候，并在线程中修改资源，就会出现线程安全问题。
//实现Runnable，重写run方法 class MyRunable implements Runnable{ private int a = 10; @Override public void run(){ while (a > 0){ try{ Thread.sleep(10); }catch (InterruptedException e){ e.printStackTrace(); } a -= 1; System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a); } } } public class TestRunable { public static void main(String[] args){ //创建 MyRunable对象 MyRunable mr = new MyRunable(); //创建线程对象 Thread t1 = new Thread(mr,"t1"); Thread t2 = new Thread(mr,"t2"); Thread t3 = new Thread(mr,"t3"); //运行线程 t1.start(); t2.start(); t3.start(); } }
由于多个线程操作变量a，导致a的值异常（-1不应该出现）。
线程安全问题都是由于多线程对全局变量进行修改操作引起的，这时就需要使用线程同步。
线程同步原理：
在一个线程操作资源时，其他线程不允许操作，保证数据的同步性。
Java中提供了三种方式来实现线程同步。
- 同步代码块：synchronized 关键字可以用于方法中的某个区块中，为区块代码添加互斥访问。
-
同步方法 :使用synchronized修饰方法。一个线程在执行该方法时，其他线程阻塞。
- Lock 锁：也称同步锁，加锁与释放锁方法化了。
同步代码块：
//实现Runnable，重写run方法 class MyRunable implements Runnable{ private int a = 10; //同步锁 Object lock = new Object(); @Override public void run(){ while (true){ synchronized (lock){ if (a > 0){ try{ Thread.sleep(50); }catch (InterruptedException e){ e.printStackTrace(); } a -= 1; System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a); } } } } } public class TestRunable { public static void main(String[] args){ //创建 MyRunable对象 MyRunable mr = new MyRunable(); //创建线程对象 Thread t1 = new Thread(mr,"t1"); Thread t2 = new Thread(mr,"t2"); Thread t3 = new Thread(mr,"t3"); //运行线程 t1.start(); t2.start(); t3.start(); } }
同步方法:
//实现Runnable，重写run方法 class MyRunable implements Runnable{ private int a = 10; @Override public void run(){ while (true) { method1(); } } //同步方法 public synchronized void method1(){ if (a > 0){ try{ Thread.sleep(50); }catch (InterruptedException e){ e.printStackTrace(); } a -= 1; System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a); } } } public class TestRunable { public static void main(String[] args){ //创建 MyRunable对象 MyRunable mr = new MyRunable(); //创建线程对象 Thread t1 = new Thread(mr,"t1"); Thread t2 = new Thread(mr,"t2"); Thread t3 = new Thread(mr,"t3"); //运行线程 t1.start(); t2.start(); t3.start(); } }
Lock锁包含两个方法：
- public void lock() :加同步锁。
- public void unlock() :释放同步锁。
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; //实现Runnable，重写run方法 class MyRunable implements Runnable{ private int a = 10; //同步锁 Lock lock = new ReentrantLock(); @Override public void run(){ while (true){ //加锁 lock.lock(); if (a > 0){ try{ Thread.sleep(20); }catch (InterruptedException e){ e.printStackTrace(); } a -= 1; System.out.println("线程"+Thread.currentThread().getName()+"操作了a，a的值为"+a); } //释放锁 lock.unlock(); } } } public class TestRunable { public static void main(String[] args){ //创建 MyRunable对象 MyRunable mr = new MyRunable(); //创建线程对象 Thread t1 = new Thread(mr,"t1"); Thread t2 = new Thread(mr,"t2"); Thread t3 = new Thread(mr,"t3"); //运行线程 t1.start(); t2.start(); t3.start(); } }
3.线程状态
- NEW：线程创建未启动。
- Runnable：可运行。
- Blocked：锁阻塞。当一个线程获得同步锁时，其他线程会被阻塞，直到获得同步锁。
- Waiting：无限等待。当一个线程进入Waiting状态后，会无限等待，直到其他线程调用notify或者notifyAll方法唤醒（线程通信）。
- TimedWaiting：计时等待。当一个线程调用sleep方法时，程序会进入计时等待，直到时间结束。
-
Teminated：被终止。run方法未正常退出而死亡。
温馨提示
- 如果您对本文有疑问，请在评论部分留言，我会在最短时间回复。
- 如果本文帮助了您，也请评论关注，作为对我的一份鼓励。
- 如果您感觉我写的有问题，也请批评指正，我会尽量修改。
