当前位置： 首页 > wzjs >正文

织梦做音乐网站寻找合肥网站建设

wzjs 2025/9/23 8:50:24
织梦做音乐网站,寻找合肥网站建设,wordpress acf 收费,做外贸没有网站可以吗文章目录程序、进程、线程线程的创建和使用继承Thread类实现Runnable接口比较创建线程的两种方式Thread类的有关方法线程的优先级获取和设置当前线程的优先级说明线程的生命周期线程的同步Synchronized的使用方法同步机制中的锁释放锁的操作线程的死锁问题synchronized与Lock的…

文章目录

  • 程序、进程、线程
  • 线程的创建和使用
    • 继承Thread类
    • 实现Runnable接口
    • 比较创建线程的两种方式
    • Thread类的有关方法
    • 线程的优先级
    • 获取和设置当前线程的优先级
    • 说明
  • 线程的生命周期
  • 线程的同步
    • Synchronized的使用方法
    • 同步机制中的锁
    • 释放锁的操作
    • 线程的死锁问题
    • synchronized与Lock的异同
  • 线程的通信
  • JDK5.0新增线程创建方式
    • 创建线程的方式三:实现Callable接口
    • 创建线程的方式四:使用线程池
    • Callable接口的方式比实现Runnable接口方式对比

程序、进程、线程

  1. 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。
  2. 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
  3. 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的
    • 若一个进程同一时间并行执行多个线程，就是支持多线程的
    • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
    • 多个线程操作共享的系统资源可能就会带来安全的隐患。
  4. 使用多线程的优点
    • 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
    • 提高计算机系统CPU的利用率
    • 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

线程的创建和使用

继承Thread类

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run() -->将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()
    • 启动当前线程
    • 调用当前线程的run()
//例子:遍历10以内的所有偶数
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{//2.重写Thread类的run()@Overridepublic void run() {for(int i=0;i<100;i++){if(i%2==0){System.out.println(i);}}}
}public class ThreadTest {public static void main(String[] args) {//3.创建Thread类的子类的对象MyThread t1 = new MyThread();//4.通过此对象调用start():1启动当前线程 2调用当前线程的run()t1.start();//问题一:我们不能通过直接调用run()的方式启动线程.//t1.run();//问题二:再启动一个线程,遍历10以内的偶数,不可以还让已经start()的新城区执行,会报错//t1.start();//我们需要重新创建一个线程的对象MyThread t2 = new MyThread();t2.start();//如下操作仍然在main线程中执行的.for(int i=0;i<100;i++){if(i%2!=0){System.out.println("*************main***********");}}}
}

实现Runnable接口

  1. 创建一个实现Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法:run()
  3. 创建实现类的对象
  4. 将对象作为参数传递到Thread类的构造器中,创建Thread类的对象
  5. 通过Thread类的对象调用start()
//1.创建一个实现Runnable接口的类
class MThread implements Runnable {//2.实现类去实现Runnable中的抽象方法:run()@Overridepublic void run() {for (int i = 0; i <= 100; i++) {if (i%2==0) {System.out.println(Thread.currentThread().getName()+":"+i);}}}
}public class ThreadTest1 {public static void main(String[] args) {//3.创建实现类的对象MThread mThread = new MThread();//4.将对象作为参数传递到Thread类的构造器中,创建Thread类的对象Thread t1=new Thread(mThread);t1.setName("线程1");//5.通过Thread类的对象调用start(): 1.启用线程 2.调用当前的run()-->调用了Runnable类型的targett1.start();//再启动一个线程,遍历100以内的偶数Thread t2=new Thread(mThread);t2.setName("线程2");t2.start();}
}

比较创建线程的两种方式

  1. 区别
    • 继承Thread：线程代码存放Thread子类run方法中。
    • 实现Runnable：线程代码存在接口的子类的run方法。
  2. 实现方式的好处
    • 避免了单继承的局限性
    • 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

Thread类的有关方法

  1. void start(): 启动线程，并执行对象的run()方法
  2. run(): 线程在被调度时执行的操作
  3. getName(): 返回线程的名称
  4. setName(String name):设置该线程名称
  5. Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
  6. yield():释放当前cpu的执行权
  7. join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
  8. sleep(long millis)：让当前线程"睡眠"指定的时间.在指定的毫秒时间内,当前线程是阻塞状态

线程的优先级

  1. 线程的优先级等级
    • MAX_PRIORITY：10
    • MIN _PRIORITY：1
    • NORM_PRIORITY：5

获取和设置当前线程的优先级

  1. getPriority() ：返回线程优先值
  2. setPriority(int newPriority) ：改变线程的优先级

说明

  1. 线程创建时继承父线程的优先级
  2. 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

线程的生命周期

  1. 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  2. 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  3. 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
  4. 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
  5. 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的同步

Synchronized的使用方法

  1. Java对于多线程的安全问题提供了专业的解决方式：同步机制
  • 方式一:同步代码块
    synchronized(同步监视器){
    //需要被同步的代码
    }
class Window1 implements Runnable{private int ticket=100;Object obj=new Object();@Overridepublic void run() {while (true){synchronized (obj){if (ticket>0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" 卖票,票号为:"+ticket--);}else{break;}//                try {
//                    Thread.sleep(10); // 添加微小延迟
//                } catch (InterruptedException e) {
//                    Thread.currentThread().interrupt();
//                    return;
//                }}}}
}public class WindowTest1 {public static void main(String[] args) {Window1 w=new Window1();Thread t1=new Thread(w);Thread t2=new Thread(w);Thread t3=new Thread(w);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}
  • 方式二:同步方法
    public synchronized void show (String name){
    ….
    }
class Window3 implements Runnable{private int ticket=100;@Overridepublic void run() {while (true){show();}}private synchronized void show(){//同步监视器:thisif (ticket>0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" 卖票,票号为:"+ticket--);}
//            else{
//                break;
//            }}}public class WindowTest3{public static void main(String[] args) {Window3 w=new Window3();Thread t1=new Thread(w);Thread t2=new Thread(w);Thread t3=new Thread(w);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

同步机制中的锁

  1. synchronized的锁
    • 任意对象都可以作为同步锁。
    • 同步方法的锁：静态方法（类名.class）、非静态方法（this）
    • 同步代码块：自己指定，很多时候也是指定为this或类名.class
  2. 注意
    • 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
    • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
class Window implements Runnable{private int ticket=100;//1.实例化ReentrantLockprivate ReentrantLock lock=new ReentrantLock();@Overridepublic void run() {while(true){try{//2.调用锁定方法Lock()lock.lock();if (ticket>0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+":售票,票号为"+ticket--);}else{break;}}finally{//3.调用解锁方法lock.unlock();}}}
}public class LockTest {public static void main(String[] args) {Window w=new Window();Thread t1=new Thread(w);Thread t2=new Thread(w);Thread t3=new Thread(w);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}
}

释放锁的操作

  1. 当前线程的同步方法、同步代码块执行结束。
  2. 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
  4. 当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。

线程的死锁问题

  1. 死锁
    • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
    • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  2. 解决方法
    • 专门的算法、原则
    • 尽量减少同步资源的定义
    • 尽量避免嵌套同步

synchronized与Lock的异同

  1. 同:二者都可以解决线程安全问题
  2. 不同:synchronized机制在执行完相应的同步代码块以后,自动的释放同步监视器
    Lock需要手动的启用同步(Lock()),同时,结束同步也需要手动的实现(unlock())
  3. 优先使用顺序:Lock->同步代码快–>同步方法

线程的通信

  1. 线程通信涉及到的三个方法:
    • wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器.
    • notify():一但执行此方法,就会唤醒wait的一个线程,如果有多个线程被wait,就唤醒优先级高的那个
    • notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
  2. 说明
    • wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中.
    • wait(),notify(),notifyAll()三个方法的调用者必须是同步代码快或同步方法中的同步监视器,否则会出现IllegalMonitorStateException
    • .wait(),notify(),notifyAll()三个方法中是定义在java.lang.Object类中.
  3. sleep() 和wait()的异同
    • 相同点:一旦执行方法,都可以使当前的线程进入阻塞状态.
    • 不同点:
      1)两个方法声明的位置不一样:Thread类中声明sleep(),Object类中声明wait().
      2)调用的要求不同:sleep()可以在任何需要的场景下调用.
      wait()必须在同步代码快或同步方法中.
      3)关于是否释放同步监视器:如果两个方法都是用它在同步代码快或同步方法中,
      sleep()不会释放锁,wait()会释放锁

JDK5.0新增线程创建方式

创建线程的方式三:实现Callable接口

  1. 创建一个实现Callable的实现类
  2. 实现call方法,将此线程需要执行的操作声明在call()中
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为传递到FutureTask的对象
  5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
  6. 获取Callable中call方法的返回值
//1.创建一个实现Callable的实现类
class NumThread implements Callable{//2.实现call方法,将此线程需要执行的操作声明在call()中@Overridepublic Object call() throws Exception {int sum=0;for (int i=1;i<=100;i++){if(i%2==0){System.out.println(i);sum+=i;}}return sum;}
}public class ThreadNew {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread=new NumThread();//4.将此Callable接口实现类的对象作为传递到FutureTask的对象FutureTask futureTask=new FutureTask(numThread);//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()Thread t1=new Thread(futureTask);t1.start();try {//6.获取Callable中call方法的返回值//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值Object sum=futureTask.get();System.out.println("总和为:"+sum);} catch (InterruptedException e) {throw new RuntimeException(e);} catch (ExecutionException e) {throw new RuntimeException(e);}}
}

创建线程的方式四:使用线程池

  1. 线程池的创建
    • 提供指定线程数量的线程池
    • 执行指定的线程的操作,需要提供Runnable接口或Callable接口实现类的对象
    • 关闭连接池
  2. 优势

    • 提高响应速度（减少了创建新线程的时间）

    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

    • 便于线程管理

      corePoolSize：核心池的大小
      maximumPoolSize：最大线程数
      keepAliveTime：线程没有任务时最多保持多长时间后会终止

  3. 线程池相关API
  • JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    execute:执行任务/命令，没有返回值，一般用来执行Runnable
    submit:执行任务，有返回值，一般又来执行Callable
    shutdown() ：关闭连接池
  • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
    Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
    Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
    Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
    Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
class NumberThread implements Runnable{@Overridepublic void run() {for(int i=0;i<=100;i++){if(i%2==0){System.out.println(Thread.currentThread().getName()+":"+i);}}}
}class NumberThread1 implements Runnable{@Overridepublic void run() {for(int i=0;i<=100;i++){if(i%2!=0){System.out.println(Thread.currentThread().getName()+":"+i);}}}
}class NumberThread2 implements Callable {@Overridepublic Object call() throws Exception {for(int i=0;i<=100;i++){if(i%5==0){System.out.println(Thread.currentThread().getName()+":"+i);}}return null;}
}public class ThreadPool {public static void main(String[] args) {//1.提供指定线程数量的线程池ExecutorService service=Executors.newFixedThreadPool(10);//设置线程池的属性System.out.println(service.getClass().getName());//2.执行指定的线程的操作,需要提供Runnable接口或Callable接口实现类的对象service.execute(new NumberThread());//适合适用于Runnableservice.execute(new NumberThread1());//service.submit(new NumberThread2());//适合使用于Callable//3.关闭连接池service.shutdown();//关闭}
}

Callable接口的方式比实现Runnable接口方式对比

  1. call()可以有返回值
  2. call()可以抛出异常,被外面的操作捕获,获取异常的信息
  3. Callable是支持泛型的
http://www.dtcms.com/wzjs/839163.html

相关文章：

  • 企业网站的推广形式有wordpress 加入引导页
  • 农产品网站策划大同网站建设制作哪家好
  • 经典网站建设方案长锦船公司网站
  • 高碑店做网站的公司做网站推广托管注意
  • dedecms网站怎么搬家删除wordpress
  • 做视频网站注意事项东城区网站排名seo
  • iis 网站没有上传权限程序员分为六个等级
  • 关于手表的网站贵阳花果园r区网站建设
  • 营销型网站用什么系统工商局网站实名认证怎么做
  • 口碑营销平台短视频seo服务
  • 服装 营销型网站案例wordpress cloud fountry
  • 大连 做网站网站建设7个基
  • 网站建设设计时代创信好wordpress云储存缩略图wpjam
  • 网站建设完成汇报北京企业官网网站建设报价
  • 高端手机网站设计wordpress默认中文
  • 怎么通过做网站来赚钱吗天津在线制作网站
  • 有微重庆网站吗企业管理系统项目经历
  • 江西省住房保障建设厅网站兰州seo关键词优化
  • top的域名网站做冰饮视频网站
  • 天津建设网站天津市地铁规划图如何查询网站服务器地址
  • 自建营销型网站模板平台公司会倒闭吗
  • 哪个网站可以做身份核验权威发布公众号
  • 庆阳定制网站wordpress文章页面修改
  • 手机wap网站建设解决方案百度指数的需求指数
  • 做宾馆网站wordpress-
  • 住宅和城乡建设部网站深圳网站建设公司fantodo
  • 滁州做网站公司什么平台可以接国外订单
  • 网站浮动窗口怎么做贵州省住房和城乡建设厅网网站首页
  • 高级网站设计效果图新乡网络公司推荐
  • 机关网站建设工程总结做兼职的网站有哪些工作内容