wordpress昨英文,湘潭seo公司,wordpress自定义面板,府网站建设先进个人线程
1. 线程 定义#xff1a;线程是进程的组成部分#xff0c;不同的线程执行不同的任务#xff0c;不同的功能模块#xff0c;同时线程使用的资源师由进程管理#xff0c;主要分配CPU和内存。 在进程中#xff0c;线程执行的方式是抢占式执行操作#xff0c;需要考…线程
1. 线程 定义线程是进程的组成部分不同的线程执行不同的任务不同的功能模块同时线程使用的资源师由进程管理主要分配CPU和内存。 在进程中线程执行的方式是抢占式执行操作需要考虑的是当前的线程是否持有CPU的执行权和等待权同时关注线程的状态。 多线程有了多线程我们就可以让程序同时处理多个事件。作用能够快速提高效率。 并发和并行的区别 并发表示的是在同一时刻多个任务在单个的CPU上的交替执行的操作。并行表示的是在单位时间内多个处理器或者多核处理器的同时处理的方式是真正意义上的同时进行。串行表示的是有N个任务通过一个线程进行顺序的执行操作由于任务中只存在一个任务方法都是在一个线程的执行的所以不存在线程的不安全的情况也就是不存在临界区的问题。比如两个人排队使用一台电脑。1.1 多线程的优点 有利于提高CPU的利用效率允许单个程序创建多个并行执行的线程来完成各自的任务 1.2 多线程的缺点 线程也是程序所以线程是需要进行内存的占用的线程越多内存的占用越多多线程需要进行协调和管理所以需要CPU时间跟踪线程线程之间对于共享资源的访问是相互影响的必须解决竞用共享资源的问题。 1.3 守护线程 守护线程是运行在后台的为其他的前台的线程提供服务的也可以说守护线程是JVM中非守护线程的“佣人”一旦所有的线程都结束运行守护线程会随着JVM进行运行操作。2. 线程的创建
2.1 通过继承Thread类的方式 Tread类是线程类一种反方是将类声明为Thread的子类的方式该子类的应该通过重写run方法的方式来创建线程。 使用的步骤格式 自己定义一个类继承Thread重写run方法创建子类对象而且进行线程的启动 class MyThread1 extends Thread {Overridepublic void run() {// 线程代码}
}main() {// 实例化自定义继承 Thread 类子类对象MyThread1 mt1 new MyThread1();// 利用继承父类 Thread 中的 start 方法启动线程。【切记不可以直接调用 run 方法】mt1.start();
}【重点】 为什么我们通过调用start方法来执行run方法而不是直接调用run方法 首先new一个Tread线程线程进入到新创建的状态中调用start方法会启动一个线程并且将线程进入到就绪的状态当分配到时间片的时候就能够进行工作了。start() 方法会执行线程的准备工作然后自己进行执行run() 方法的内容这才是真正的多线程的工作。直接执行run方法的时候main方法会将其看做一个普通的反方进行执行操作并不会在某个线程中去执行它所以不是多线程的工作。 2.2 通过实现Runnable接口 多线程的创建的步骤 自己定义一个类实现Runnable接口重写里面的run方法创建自己的类对象创建一个Tread类的对象Runnable作为参数传入并且开启线程 Runnable 接口是一种函数式接口FuncationalInterface 能够使用lambda表达式。 class MyThread2 implements Runnable {Overridepublic void run() {// 线程代码}
}main() {/*可以利用 Thread 类构造方法实例化目标线程对象执行对应线程目标将 Runnable 接口的实现类对象作为 Thread 构造方法参数构造方法 Thread(Runnable target);构造方法的作用是以 Runnable 接口实现类为当前线程的执行目标new 关键字 构造方法实例化线程对象*/Thread t1 new Thread(new MyThread2());t1.start();
}真实案例的代码实现class MyThread1 extends Thread {Overridepublic void run() {for (int i 0; i 100; i) {System.out.println(自定义线程继承 Thread 类型完成线程类);}}}class MyThread2 implements Runnable {Overridepublic void run() {for (int i 0; i 100; i) {System.out.println(自定义线程遵从 Runnable 接口实现线程类);}}
}/*** Thread 自定义线程类实现的两种方式** author Anonymous 2023/3/8 10:06*/
public class Demo1 {public static void main(String[] args) {MyThread1 mt1 new MyThread1();Thread mt2 new Thread(new MyThread2());mt1.start();mt2.start();for (int i 0; i 100; i) {System.out.println(main方法内容...);}}
}2.3 通过实现Callable接口(有返回结果) 多线程的第三种的实现的方式 创建一个 自定义 类实现java.util.concurrent包Callable接口重写call方法有返回值表示的是多线程的运行的结果创建MyCallable的对象表示多线程要进行执行的任务创建FutureTask的对象作用是管理多线程的运行的结果创建Thread类的对象并且进行启动的操作表示线程 【注意】其中的callable是存在泛型的格式的其中的泛型表示的是返回值的泛型 //方法步骤
public class MyCallable implements CallableInteger {Overridepublic Integer call() throws Exception {/** 用来求解1~100 的和*/int sum 0;for (int i 0; i 100; i) {sum i;}return sum;}
}// 测试实现操作
public class TestMain {public static void main(String[] args) throws ExecutionException, InterruptedException {/** 1. 创建MyCallable的对象表示的是多线程要执行的任务*/MyCallable myCallable new MyCallable();/*2. 创建FutureTask的对象作用是用来管理多线程的运行的结果*/FutureTaskInteger integerFutureTask new FutureTask(myCallable);/** 3. 创建线程的对象*/Thread thread new Thread(integerFutureTask);/*4.启动线程*/thread.start();/** 获取多线程的运行的结果*/Integer integer integerFutureTask.get();System.out.println(integer);}
}总结 Tread 继承的操作编码比较简单可以直接使用Tread类中的方法可以拓展的可能性比较差不能够继承其他的类接口的方式是可拓展性是比较强的实现接口的同时还可以继承其他的类编程相对来说比较复杂不能够直接使用Tread类中方法。 2.4 线程中操作方法
方法名称作用String getName()获取指定线程对象的名称void setName(String name)针对于线程的名称获取和设置int getPriority()获取指定线程的优先级void setPriority(int newPriority)获取指定线程的优先级 默认是5 只能够提供被执行的概率不能确保一定会执行操作final void setDaemon(boolean flag)设置指定线程为守护线程boolean isDaemon()设置和判断当前线程是否为守护线程static void sleep(long time)单位是ms强迫一个线程睡眠的时间单位是毫秒级别的static Thread currentThread();在哪一个线程代码中执行获取当前线程代码对应的线程对象。static void yield()出让线程礼让线程的操作static void join()插入线程、插队线程的操作
构造方法:Thread();过Thread(Runnable target);以 Runnable 接口实现类为当前线程的执行目标new 关键字 构造方法实例化线程对象Thread(Runnable target, String threadName);以 Runnable 接口实现类为当前线程的执行目标同时明确当前线程的名字new 关键字 构造方法实例化线程对象对于指定的方法进行分析的操作1. String getName() 表示的是获取指定的线程的名称如果没有设置名称线程也会自动生成名称的通过源码我们能够看到是this当前线程 nextThreadNum(): 是一个变量的自动递增。2. void setName(String name)对于线程进行名字的设置除了调用方法的设置的方式之外还能够通过调用构造方法的方式来进行实现比如说Thread(String threadName) 以及 Thread(Runnable target, String threadName)两种方法来实现线程名称的命名。3.static Tread currentThread() 获取当前线程的对象。细节是当JVM虚拟机进行启动的时候会自动的启动多条线程其中有一条线程是main线程它的作用是调用main方法并且执行里面的代码在以前的时候我们所写的代码其实都是运行在main线程中4.static void sleep(long time)那条线程执行到这个反方那么那条线程就会在这里进行停留时间。方法的参数就表示的是睡眠的时间时间的单位毫秒。1s 1000ms 当时间到了之后线程会自动的醒来继续执行下面的其他的代码。5.final void setDaemon(boolean flag) 当其他的非守护线程执行完毕之后守护线程会陆续的结束既当其他线程结束操作之后守护线程也就没有存在的必要了。/**
* 通过实现runnable接口实现线程的创建
*/
public class MyRunnable implements Runnable{Overridepublic void run() {for (int i 0; i 10; i) {System.out.println(Thread.currentThread().getName()____i);}}
}
public class Demo1 {public static void main(String[] args) {/** 创建线程需要执行的参数对象*/Runnable runnable new MyRunnable();/** 创建线程对象*/Thread thread new Thread(runnable, 张三);Thread thread1 new Thread(runnable, 李四);/** 通过更改优先级的大小提高线程优先运行的概率不能够保证一定是优先执行的操作。*/thread.setPriority(10);thread1.setPriority(6);/** 进行线程的执行的操作需要进行开启线程操作*/thread.start();thread1.start();}
}运行的结果
李四____0
张三____0
张三____1
张三____2
张三____3
张三____4
张三____5
张三____6
张三____7
张三____8
张三____9
李四____1
李四____2
李四____3
李四____4
李四____5
李四____6
李四____7
李四____8
李四____92.5 线程的生命周期 sleep 方法会让线程睡眠睡眠的时间到了之后不会立刻执行下面的代码不会直接执行会进入到就绪的状态上然后进行线程资源的抢夺如果抢夺到资源后能够运行。 3. 线程安全 线程安全的问题对于线程安全来说所有的隐患都是出现多个线程访问的情况下产生的我们能够确保在多条线程访问的情况下我们的程序能够按照我们预期的行为去执行。 需求某电影院中目前需要上映国产的大片共有100张票需要三个窗口进行售票的行为请设计一个程序模拟电影院进行买票的行为。 // 采用继承的方式创建对象
/*** 通过继承的方式操作线程*/
public class MyThread extends Thread{/*表示的是这个类中的所有的对象都在共享tickets的数据*/static int ticket 0;Overridepublic void run() {while (true) {if (ticket 100){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket ;System.out.println(getName()正在卖ticket张票);} else {break;}}}
}// 进行检验
public class Demo1 {/***检验多线程的问题** param args*/public static void main(String[] args) {/** 1. 创建线程对象*/MyThread myThread1 new MyThread();MyThread myThread2 new MyThread();MyThread myThread3 new MyThread();/*通过调用方法起名字*/myThread1.setName(窗口1);myThread2.setName(窗口2);myThread3.setName(窗口3);/*开启线程的操作*/myThread1.start();myThread2.start();myThread3.start();}
}运行的结果......
窗口1正在卖96张票
窗口3正在卖97张票
窗口1正在卖99张票
窗口2正在卖99张票
窗口3正在卖100张票
窗口1正在卖101张票
窗口2正在卖102张票分析出现重复的数据卖出同时出现数据的溢出操作总结在进行循环的时候出现线程满足循环的条件所以进行执行的操作出现线程争夺资源的情况所以造成的问题是关于线程的安全的问题。 3.1 同步代码块 为了解决上述的问题的情况我们可以引入的方法是同步的代码块的操作把操作共享数据的资源进行加锁的操作 特点 锁默认的是打开的关系有一个线程进去锁自动关闭里面的代码全部执行完毕线程出来锁自动打开。 格式synchronized(锁){操作共享数据的代码
}// 改进的代码操作如下所示
public class MyThread extends Thread{/*表示的是这个类中的所有的对象都在共享tickets的数据*/static int ticket 0;/***针对于第一种的创建的方式可能出现创建多种的线程对象因此将之加上static 将数据共享 如果是对于方法二而言创建的只有一种Runnable对象。而且是当做参数创建线程的操作。因此不需要进行共享的声明。*/Overridepublic void run() {while (true) {//此处是更改之后的数据的操作synchronized (锁对象要求是唯一){if (ticket 100){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket ;System.out.println(getName()正在卖ticket张票);} else {break;}}}}
}改进后的运行的效果是......
窗口3正在卖95张票
窗口2正在卖96张票
窗口2正在卖97张票
窗口3正在卖98张票
窗口1正在卖99张票
窗口3正在卖100张票【重点操作】: 在锁结构中我们能够使用的过程中加上唯一的锁对象,对于锁对象的选择上来说 必须保证唯一的特性通常是一个类内会设置一个独立的变量作为锁对象使用包装类不得用于锁对象使用当前类型的Class对象可以作为锁对象但是不推荐 3.2 同步方法 使用的关键字是synchronized 限制对应的方法是有且只能通过一个线程进入到方法中执行目标的任务 重点进行区分的是有static修饰的方法是静态方法需要进行考虑的是当前锁对象的情况以及同步范围的情况。 同步方法的格式修饰符 synchronized 返回值类型 方法名称方法参数{}1.同步方法是锁住方法中的所有的代码
2. 锁对象不能够自己指定// 注意非静态的同步方法对象是当前调用方法的对象 - this
public synchronized void sale() {...}// 静态同步方法锁对象是当前类.class 类名.class 唯一的锁对象的特征
public static synchronized void staticSale() {...}3.2.1 同步方法的范围 非静态的成员方法使用的是 synchronized 同步的约束同步的范围 重点通过当前的实例化对象作为锁对象实例化对象调用任意 synchronized 修饰的同步方法所有其他的 synchronized 同步方法一律不能够进行执行的操作 java中经常使用的是ArrayList 和 Vector StringBuilder 和 StringBufferHashMap 和 HashTable 静态的成员方法使用 synchronized 同步进行约束的操作锁对象是 类名.class .无论那一条线程任何一个对象来执行目标方法都会被 类名.class 锁住其他的任意的线程任意的对象都无法执行所有其他 static 修饰的 synchronized 约束的同步方法。 例子一public static synchronized void test1() {for (int i 0; i 10; i) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Test1 方法);}
}/*
等价于
synchronized (TypeB.class) {for (int i 0; i 10; i) {try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Test1 方法);}
}*/例子二电影院售票的操作套路采用的是通过实现接口的方式来创建线程
public class MyRunnable implements Runnable{
int ticket 0;/*** 执行的套路是* 1. 循环* 2. 同步代码块* 3.判断共享数据是否到了末尾到末尾的情况* 4. 判断共享数据是否到了末尾没有到末尾的情况*/Override
public void run() {while (true) {synchronized (MyRunnable.class) {if (ticket 100){break;} else {ticket ;System.out.println(Thread.currentThread().getName()买了第ticket张票);}}}
}
}更改成为同步方法的格式为
public class MyRunnable implements Runnable{int ticket 0;/*** 执行的套路是* 1. 循环* 2. 同步代码块* 3.判断共享数据是否到了末尾到末尾的情况* 4. 判断共享数据是否到了末尾没有到末尾的情况*/Overridepublic void run() {while (true) {if (extracted()) break;}}/*** 其中的锁对象是惟一的其中的对象表示的是this即为当前的对象** return*/private synchronized boolean extracted() {if (ticket 100){return true;} else {ticket ;System.out.println(Thread.currentThread().getName()买了第ticket张票);}return false;}
}
通过创建接口对象并且将接口对象作为参数进行传入的操作*/
public class TicketDemo {public static void main(String[] args) {/*** 通过接口的实现来进行操作将接口名作为参数创建线程*/Runnable runnable new MyRunnable();Thread thread0 new Thread(runnable);Thread thread1 new Thread(runnable);Thread thread2 new Thread(runnable);thread0.setName(窗口1);thread1.setName(窗口2);thread2.setName(窗口3);thread0.start();thread1.start();thread2.start();}
}
3.3 Lock锁 Lock 实现提供的比 synchronized 方法和语句可以获取更为广泛的锁定操作Lock中提供了获的锁和释放锁的方法 void lock() 获得锁void unlock() 释放锁 lock接口是不能够进行直接的实例化操作的这里采用的它的实现类ReentrantLock 来实例化 ReentrantLock的构造方法。类ReentrantLock() 创建一个类ReentrantLock的实例。总结 手动上锁手释放锁。 手动锁的结构是static Lock mylock new ReentrantLock();
mylock.lock;try{}finally{mylcok.unlock();// 如果在临界区的代码抛出一个异常锁必须释放。否则其他的线程将永远阻塞。}
这个结构的优点是确保任何时刻都只有一个线程进入临界区一旦一个线程锁定了锁对象其他的任何线程都无法通过lock语句当其他的语句调用lock语句的时候他们会暂停直到第一个线程释放这个锁对象。出现的问题1. 创建三个线程对象lock对象的创建是在类里面2. 所以出现的是三种不同的锁所以有可能出现的是没有加锁成功3. 改正的方法可以在前面加上 static 修饰符public class MyThread extends Thread{/*表示的是这个类中的所有的对象都在共享tickets的数据*/static int ticket 0;Lock lock new ReentrantLock();Overridepublic void run() {while (true) {/*调用获得锁的方法操作,开始上锁*/lock.lock();if (ticket 100){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket ;System.out.println(getName()正在卖ticket张票);} else {break;}// 关锁的操作lock.unlock();}}
}public class Demo1 {/***检验多线程的问题** param args*/public static void main(String[] args) {/** 1. 创建线程对象*/MyThread myThread1 new MyThread();MyThread myThread2 new MyThread();MyThread myThread3 new MyThread();/*通过调用方法起名字*/myThread1.setName(窗口1);myThread2.setName(窗口2);myThread3.setName(窗口3);/*开启线程的操作*/myThread1.start();myThread2.start();myThread3.start();}
}改进之后的作用import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 通过继承的方式操作线程*/
public class MyThread extends Thread{/*表示的是这个类中的所有的对象都在共享tickets的数据*/static int ticket 0;static Lock lock new ReentrantLock();Overridepublic void run() {while (true) {/*调用获得锁的方法操作,开始上锁*/lock.lock();try {if (ticket 100){Thread.sleep(100);ticket ;System.out.println(getName()正在卖ticket张票);} else {break;}} catch (InterruptedException e) {e.printStackTrace();} finally {// 关锁的操作lock.unlock();}}}
}
3.4 死锁错误 死锁实际上是指的是两个或者两个以上的进程在执行的过程中由于竞争资源或者由于彼此的铜线而造成的一种阻塞的现象。若没有外力的作用它们无法推进下去。 3.4.1 死锁的四个必要的条件 互斥条件在一定的时间某种资源只有一个线程占用。如果此时还有其他的进程请求资源就只能够等待直到占有资源的进程用完释放占有且等待条件指进程已经保持至少一个资源但是又提出了新的资源的请求而且该资源已经被其他进程占用此时请求进程阻塞但是对于自己已经获得的其他的资源保持不放不可抢占资源别人已经占有额某项资源你不能够因为自己也需要该资源就去把别人的资源抢过来。循环等待的条件若干个进程之间形成一种头尾相接的循环等待的资源关系。 3.4.2 如何避免死锁 避免一个线程同时获得多个锁避免一个线程在锁内同时占用多个资源尽量保持每个锁只占用一种资源尝试使用定时锁使用lock.tryLock(timeout)来代替使用内部锁机制 3.5 线程安全 临界资源共享资源同一个对象一次只可以有一个线程操作才能够保证准确性原子操作不可拆分的步骤被视为一个整体其中的步骤不能够被打乱。 3.6 线程不安全 完整的步骤可能会被破坏线程内的数据可能会被别的线程修改 举例 public class Printer extends Thread{// 锁需要是同一对象private Object obj new Object();// 打印机1号public synchronized void print1() {//synchronized (obj){System.out.print(1 );System.out.print(2 );System.out.print(3 );System.out.print(4 );System.out.print(\r\n);//}}// 打印机2号public synchronized void print2() {//synchronized (obj) {System.out.print(一 );System.out.print(二 );System.out.print(三 );System.out.print(四 );System.out.print(\r\n);//}}
}public class Demo1 {public static void main(String[] args) {Printer printer new Printer( );// 线程1new Thread(() - {while(true){printer.print1();}}).start();// 线程2new Thread(() - {while(true){printer.print2();}}).start();}
}
