java多线程学习（二）

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量398 收藏
点赞数
分类专栏： java 文章标签： java 多线程 线程

java多线程学习（二）

标签（空格分隔）： java 线程

线程的优先级别

java提供一个线程调度器来监控程序中启动后所有进入就绪状态的线程，线程调度器按照线程优先级执行线程。
线程优先级从1到10，用数字表示，从低到高，缺省的默认值为5

使用下面方法设置或者获取线程的优先级：

- int getPriority()
- void setPriority(int num)

java 线程使用

/**
 * 
 */
package com.frankstar.Thread;

/**
 * @author frankstar
 * 线程优先级测试
 */
public class PriorityThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TestPriorityThread1 tpt1 = new TestPriorityThread1();
        TestPriorityThread2 tpt2 = new TestPriorityThread2();
        Thread t1 = new Thread(tpt1);
        Thread t2 = new Thread(tpt2);

//      t1.start();
//      t2.start();  //先看未设置优先级的进程
//      这里的优先级指的是执行一次的时间会较长即占据CPU时间片的时间会比较多
        t1.setPriority(Thread.NORM_PRIORITY + 3);
        t1.start();
        t2.start();

        System.out.println("t1的优先级为: " + t1.getPriority());

    }

}
class TestPriorityThread1 implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i <= 5; i++) {
            System.out.println("1st: " + i);
        }
    }

}
class TestPriorityThread2 implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i <= 5; i++) {
            System.out.println("2st: " + i);
        }
    }

}

线程的同步

- java中，引入了互斥锁的概念，保证共享数据操作的完整性。每一个对象都对应一个称为“互斥锁”的 标记，这个标记保证了在任何时刻，只能有一个线程访问此对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象使用synchronized关键字修饰时，表示此对象在任何时刻，只能有一个线程访问。

synchronized案例

/**
 * 
 */
package com.frankstar.Thread;

/**
 * @author frankstar
 * 测试同步
 *
 */
public class SyncThread  implements Runnable{

    Timer timer = new Timer();

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SyncThread st = new SyncThread();
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);
        t1.setName("frank");
        t2.setName("star");
        t1.start();
        t2.start();


    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        timer.add(Thread.currentThread().getName());
    }

}

class Timer {
    private static int num = 0;

    public /*synchronized */void add(String name) {
        //在声明方法时加入synchronized表示执行这个方法的过程中当前对象被锁定
        synchronized(this) {
            //锁定当前对象
            num++;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(name + ": 你是第" + num + "个使用timer");
        }

    }


}

线程锁定 　解决线程死锁的问题最好只锁定一个对象，不要同时锁定两个对象

/**
 * 
 */
package com.frankstar.Thread;

/**
 * @author frankstar
 * 线程死锁问题
 */
public class LockThread implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LockThread lt1 = new LockThread();
        LockThread lt2 = new LockThread();

        lt1.flag = 1;
        lt2.flag = 0;

        Thread t1 = new Thread(lt1);
        Thread t2 = new Thread(lt2);

        t1.setName("frank");
        t2.setName("star");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName() + " flag = " + flag);
//      这里的两个if语句都将无法执行，因为已经造成了线程死锁的问题 
//      flag=1这个线程在等待flag=0这个线程把对象o2的锁解开， 
//      而flag=0这个线程也在等待flag=1这个线程把对象o1的锁解开 
//      然而这两个线程都不愿意解开锁住的对象，所以就造成了线程死锁的问题
        if (flag == 1) {
            synchronized (o1) { //锁定o1对象 只有o1这个线程对象执行完毕才会释放锁
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(o2) {
//                  前面已经锁住了对象o1，只要再能锁住o2，那么就能执行打印出1的操作了 
//                  可是这里无法锁定对象o2，因为在另外一个flag=0这个线程里面已经把对象o1给锁住了 
//                  尽管锁住o2这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o2不放的
                    System.out.println("1");
                }
            }

        }
        if (flag == 0) {
            synchronized (o2) { //锁定o2对象 只有o2这个线程对象执行完毕才会释放锁
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(o1) {
//                  前面已经锁住了对象o1，只要再能锁住o2，那么就能执行打印出1的操作了 
//                  可是这里无法锁定对象o2，因为在另外一个flag=0这个线程里面已经把对象o1给锁住了 
//                  尽管锁住o2这个对象的线程会每隔500毫秒睡眠一次，可是在睡眠的时候仍然是锁住o2不放的
                    System.out.println("1");
                }
            }

        }

    }

}

线程案例

/**
 * 
 */
package com.frankstar.Thread;

/**
 * @author frankstar
 * 生产者－消费者问题
 * 1.共享数据的不一致性／临界资源的保护
 * 2.java对象锁的概念
 * 3.synchronized关键字/wait() notify()
 */
public class ProducerConsumer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SyncStack ss = new SyncStack();
        Runnable p = new Producer(ss);
        Runnable c = new Consumer(ss);

        Thread p1 = new Thread(p);
        Thread c1 = new Thread(c);

        p1.start();
        c1.start();

    }

}
class SyncStack {
    //支持多线程同步操作的堆栈实现
    private int index = 0;
    private char []data = new char[6];
    public synchronized void push (char c) {
        if (index == data.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {}
        }
        this.notify();
        data[index] = c;
        index++;
    }
    public synchronized char pop() {
        if (index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {}
        }
        this.notify();
        index--;
        return data[index];
    }
}
class Producer implements Runnable {
    SyncStack stack;
    public Producer (SyncStack s) {
        stack = s;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 0; i < 10; i++){
            char c = (char)(Math.random()*26 + 'A');
            stack.push(c);
            System.out.println("生产： " + c);
            try {
                Thread.sleep((int)(Math.random()*1000));
            } catch (InterruptedException e){

            }
        }

    }
}
class Consumer implements Runnable {
    SyncStack stack;
    public Consumer(SyncStack s) {
        stack = s;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < 10; i++) {
            char c = stack.pop();
            System.out.println("消费: " + c);
            try {
                Thread.sleep((int) (Math.random()*1000));
            } catch (InterruptedException e) {

            }
        }
    }

}
frankstars
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程实验心得体会_JAVA多线程学习心得（一）
weixin_32873435的博客
02-27 2162
最近在github上写了几个关于多线程的练习， 项目地址：https://github.com/jndf/multithreading-pratice需要的朋友可以看看，代码如有错误，请多提出指正意见。下面说一下最近的一些心得。Thread和Runnable两种实现方式。这两种方法都是最基础的实现线程的方法，声明线程对象后，通过调用对象的start()方法，来执行线程内部的run()方法。其中Ru...
java多线程学习
11-27
主要是结合课本和视频学习了一下java多线程的用法，这个专利适合于初学者学习多线程知识。
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 40万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
编程必备：JAVA多线程详解
拾一二的博客
06-14 6893
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java 多线程学习
hua226的博客
04-13 2万+
Java 多线程 一、实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配和调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.3 多线程的实现方式 多线程的实现方案有两种： 继承Thread类 实现Runnable接口 方式1：继承Thread类 定义一个MyThread类继承Thread类 在M
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
真的还有必要学习JAVA多线程吗？
02-19 5万+
JAVA多线程是不是真的没必要再学了？
java 多线程参数及说明
qq_39275467的博客
05-17 1711
一、corePoolSize 线程池核心线程大小 线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。 二、maximumPoolSize 线程池最大线程数量 一个任务被提交到线程池后，首先会缓存到工作队列（后面会介绍）中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它
Java多线程的知识点
weixin_59796310的博客
05-28 4826
Java多线程的知识点
Java多线程学习总结
09-14
资源包含以下内容：  Java 线程及进程  Java 中的线程类(Thread)  Java 中的 Runnable 接口  两种实现多线程方式的对比分析  Java 中线程的同步
java多线程学习视频
10-30
Java多线程是一块重要的内容，李兴华讲解的Java是一个很好的资源
Java-学习多线程总结上
12-22
所以在进程之上的进一步划分就变得非常的重要，而且性能也会有所提高，所有的线程一定要依附进程才能够存在，那么进程一旦消失，线程也一定会消失，但反过来不一定，而Java是支持多线程的开发语言之一。 2. 多线程的...
JAVA多线程与并发学习总结分析
09-05
以下是对小编对JAVA多线程与并发的学习进行了总结介绍，需要的朋友可以过来参考下
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1207
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1077
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1119
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
java多线程 学习
04-19
Java多线程是指在Java程序中同时执行多个线程的机制。通过使用多线程，可以实现并发执行，提高程序的效率和响应性。在Java中，可以通过以下几种方式来实现多线程： 1. 继承Thread类：创建一个继承自Thread类的子类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值