您好,登录后才能下订单哦!
这篇文章主要讲解了JAVA多线程的用法,内容清晰明了,对此有兴趣的小伙伴可以学习一下,相信大家阅读完之后会有帮助。
线程概念
进程:启动一个应用程序就叫一个进程。 接着又启动一个应用程序,这叫两个进程。每个进程都有一个独立的内存空间;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程:线程是在进程内部同时做的事情,一个进程中可以有多个线程,这个应用程序也可以称之为多线程程序。
一个程序运行后至少有一个进程,一个进程中可以包含多个线程
线程调度:
创建多线程
方法一:创建Thread类的子类
//方法一: //定义Thread类的子类,并重写该类的run()方法 public class MyThreadDemo01 extends Thread { @Override public void run() { for (int i = 0; i < 20 ; i++) { System.out.println(getName()+"-->"+i); } } }
//主线程 public class MainThread01 { public static void main(String[] args) { //创建Thread子类的实例,即创建了线程对象 MyThreadDemo01 thread01 = new MyThreadDemo01(); //调用线程对象的start()方法来启动该线程 thread01.start(); for (int i = 0; i < 10 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
方法二:实现Runnable接口
//方法二: //定义Runnable接口的实现类,并重写该接口的run()方法,设置线程任务 public class MyThreadDemo02 implements Runnable{ @Override public void run() { for (int i = 0; i < 10 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }
//主线程 public class MainThread { public static void main(String[] args) { //创建Runnable实现类对象 MyThreadDemo02 runnable = new MyThreadDemo02(); //创建Thread类的对象,并且该对象构造方法中传递Runnable实现类对象 Thread thread02 = new Thread(runnable); //调用Thread对象的start()方法来启动线程 thread02.start(); for (int i = 0; i < 20 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }
方法三:匿名内部类方式
//方法三:匿名内部类 public class MainThread { public static void main(String[] args) { //Thread方式 new Thread(){ @Override public void run() { for (int i = 0; i < 10 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }.start(); //Runnable接口方式 new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 10 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }).start(); //////////////////////////////////////////////// for (int i = 0; i < 20 ; i++) { System.out.println(Thread.currentThread().getName()+"-->"+i); } } }
线程安全问题
多线程访问共享数据,,且多个线程中对资源有写的操作,就会出现线程安全问题
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步, 否则的话就可能影响线程安全。
解决线程安全问题采用线程同步机制,主要有以下三种方式:
同步代码块
同步代码块:synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。
public class SafeRunnableDemo implements Runnable { private int ticket = 100; //同步代码块 //创建锁对象 Object lock = new Object(); @Override public void run() { while (true){ //锁住同步代码块 synchronized (lock){ if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张"); ticket--; } } } } }
同步方法
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着
public class SafeRunnableDemo implements Runnable { private int ticket = 100; //同步方法 //定义一个同步方法 public synchronized void lock(){ //同步方法锁住代码块 if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张"); ticket--; } } //重写run并使用同步方法 @Override public void run() { while (true){ lock(); } } }
Lock锁
Lock提供了比synchronized更广泛的锁操作
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SafeRunnableDemo implements Runnable { private int ticket = 100; //Lock锁方法 //创建ReentrantLock对象 Lock lock = new ReentrantLock(); @Override public void run() { while (true){ //在可能出现问题的代码块之前用lock()方法 lock.lock(); if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张"); ticket--; } //在可能出现问题的代码块之后用unlock()方法 lock.unlock(); } } }
线程机制
一个调用了某个对象的 Object.wait() 方法的线程会等待另一个线程调用此对象Object.notify()方法 或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作,它体现的是多个线程间的通信,可以理解为多个线程之间的协作关系, 多个线程会争取锁,同时相互之间又存在协作关系。
当多个线程协作时,比如A,B线程,如果A线程在Runnable(可运行)状态中调用了wait()方法那么A线程就进入 了Waiting(无限等待)状态,同时失去了同步锁。假如这个时候B线程获取到了同步锁,在运行状态中调用了 notify()方法,那么就会将无限等待的A线程唤醒。注意是唤醒,如果获取到锁对象,那么A线程唤醒后就进入 Runnable(可运行)状态;如果没有获取锁对象,那么就进入到Blocked(锁阻塞状态)。
public class WaitAndSleep { public static void main(String[] args) { //创建锁对象 Object lock = new Object(); //匿名内部类创建线程1 new Thread(){ @Override public void run() { System.out.println(Thread.currentThread().getName()+"需要买票"); //用同步代码块包裹 synchronized (lock){ try { //lock.wait(5000);//到5秒自动醒来 lock.wait();//进入无限等待,需要唤醒 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName()+"买到了票"); } }.start(); //匿名内部类创建线程2 new Thread(){ @Override public void run() { try { Thread.sleep(5000);//等待5秒 System.out.println(Thread.currentThread().getName()+"出票了"); } catch (InterruptedException e) { e.printStackTrace(); } //用同步代码块包裹 synchronized (lock){ lock.notify();//如果有多个线程等待,随机唤醒一个 //lock.notifyAll();//唤醒所有等待的线程 } } }.start(); } }
线程池
当在系统中用到了很多的线程,大量的启动和结束动作会导致系统的性能变卡,响应变慢,采用线程池可以解决这个问题。线程池就相当于一个容器(如同ArrayList),执行的任务放入线程池中,多出来的任务就等待线程池中的任务执行完再放入。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //线程池 public class ThreadPoolMain { public static void main(String[] args) { //使用线程池的工厂类 Executors里的静态方法 newFixedThreadPool // 生产指定线程数量的线程池,返回为ExecutorService接口 ExecutorService es = Executors.newFixedThreadPool(2); //调用ExecutorService中的submit方法,传递线程任务,开启线程 es.submit(new ThreadPoolDemo01()); } } ////////////////////////////////////////////////////// //创建一个类实现Runnable接口,重写run方法,设置线程任务 public class ThreadPoolDemo01 implements Runnable{ @Override public void run() { ... } }
看完上述内容,是不是对JAVA多线程的用法有进一步的了解,如果还想学习更多内容,欢迎关注亿速云行业资讯频道。
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。