多线程编程核心技术-java多线程技能(1)(上)

简介: 多线程编程核心技术-java多线程技能(1)(上)

进程和多线程的概念以及线程的优点


1.进程概念



1dc618a0ed9580ce8bfa6facb208c08f.png


2.线程概念


5d4c6812c8535adbb050f4ddf2e1bce8.png


3.优点



46a9d80a6e05e4e3b19d57a0ee70bcdf.png


使用多线程


接触下线程


public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

66ba272a0bfc97be54a5fa679e3d5482.png


1.继承Thread类


代码运行和代码执行和调用顺序无关


自定义一个线程类:


public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        System.out.println("Mythead");
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println("运行结束!");
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png

5d4c6812c8535adbb050f4ddf2e1bce8.png


线程调用的随机性


public class RandomThread extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);
                System.out.println("run==" + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        try {
            RandomThread randomThread = new RandomThread();
            randomThread.setName("myThread");
            randomThread.start();
            for (int i = 0; i < 10; i++) {
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time);
                System.out.println("run==" + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("run==" + Thread.currentThread().getName());
    }
}

46a9d80a6e05e4e3b19d57a0ee70bcdf.png


66ba272a0bfc97be54a5fa679e3d5482.png


执行start方法的顺序不代表线程启动顺序


public class ThreadDemo extends Thread{
    private int i;
    public ThreadDemo(int i){
        super();
        this.i = i;
    }
    @Override
    public void run() {
        System.out.println(i);
    }
    public static void main(String[] args) {
        ThreadDemo t1 = new ThreadDemo(1);
        ThreadDemo t2 = new ThreadDemo(2);
        ThreadDemo t3 = new ThreadDemo(3);
        ThreadDemo t4 = new ThreadDemo(4);
        ThreadDemo t5 = new ThreadDemo(5);
        ThreadDemo t6 = new ThreadDemo(6);
        ThreadDemo t7 = new ThreadDemo(7);
        ThreadDemo t8 = new ThreadDemo(8);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
        t8.start();
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png


2.实现Runnable接口


如何使用Runable类呢?

5d4c6812c8535adbb050f4ddf2e1bce8.png

1dc618a0ed9580ce8bfa6facb208c08f.png

public class Run {
    public static void main(String[] args) {
        MyRunable myRunable = new MyRunable();
        Thread thread = new Thread(myRunable);
        thread.start();
        System.out.println("运行结束");
    }
}

5d4c6812c8535adbb050f4ddf2e1bce8.png

46a9d80a6e05e4e3b19d57a0ee70bcdf.png



3.实例变量与线程安全


5d4c6812c8535adbb050f4ddf2e1bce8.png

(1)不共享数据的情况

1dc618a0ed9580ce8bfa6facb208c08f.png


public class MyThread extends Thread {
    private int count=5;
    public MyThread(String name) {
        super();
        this.setName(name);
    }
    @Override
    public void run() {
        super.run();
        while(count > 0){
            count --;
            System.out.println("由 "  + this.currentThread().getName() + " 计算,count=" + count);
        }
    }
}


public class Run {
    public static void main(String[] args) {
        MyThread a = new MyThread("a");
        MyThread b = new MyThread("b");
        MyThread c = new MyThread("c");
        a.start();
        b.start();
        c.start();
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png

(2)共享数据的情况

1dc618a0ed9580ce8bfa6facb208c08f.png


线程安全问题案例1

测试项目


public class MyThread extends Thread{
    private int count=5;
    @Override
    public void run() {
//        super.run();
//        while(count > 0){
            count --;
            System.out.println("由 "  + this.currentThread().getName() + " 计算,count=" + count);
//        }
    }
}


public class Run {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread a = new Thread(myThread, "a");
        Thread b = new Thread(myThread,"b");
        Thread c = new Thread(myThread,"c");
        Thread d = new Thread(myThread,"d");
        Thread e = new Thread(myThread,"e");
        a.start();
        b.start();
        c.start();
        d.start();
        e.start();
    }
}


运行结果:

1dc618a0ed9580ce8bfa6facb208c08f.png

结果:每次都不一样。

5d4c6812c8535adbb050f4ddf2e1bce8.png

案例:

46a9d80a6e05e4e3b19d57a0ee70bcdf.png


public class MyThread extends Thread {
    private int count = 5;
    @Override
    synchronized public void run() {
        count--;
        System.out.println("由 " + this.currentThread().getName() + " 计算,count=" + count);
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png

5d4c6812c8535adbb050f4ddf2e1bce8.png


线程安全问题2

public class LoginServlet {
    private static String usernameRef;
    private static String passwordRef;
    public static void doPost(String username, String password){
        try {
            usernameRef = username;
            if(username.equals("a")){
                Thread.sleep(5000);
            }
            passwordRef = password;
            System.out.println("username=" + usernameRef + " password="+passwordRef);
        }catch (InterruptedException e){
           e.printStackTrace();
        }
    }
}


public class Alogin extends  Thread{
    @Override
    public void run() {
        LoginServlet.doPost("a", "aa");
    }
}


public class Blogin extends  Thread {
    @Override
    public void run() {
        LoginServlet.doPost("b", "bb");
    }
}



public class Run {
    public static void main(String[] args) {
        Alogin a = new Alogin();
        a.start();
        Blogin b = new Blogin();
        b.start();
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png

也出现了线程安全问题。


解决方式,也是加上 synchronized


synchronized   public static void doPost(String username, String password){


留意i–和system.out.println()异常

1dc618a0ed9580ce8bfa6facb208c08f.png


案例演示


public class MyThread extends Thread {
    private int i = 5;
    @Override
    public void run() {
        System.out.println("i=" + (i--)+ " threadName=" + Thread.currentThread().getName());
        //注意: 代码i--由前面项目中单独一行运行改成在当前项目中在println()方法中直接进行打印
    }
    public static void main(String[] args) {
        MyThread run = new MyThread();
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        Thread t4 = new Thread(run);
        Thread t5 = new Thread(run);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }    
}

1dc618a0ed9580ce8bfa6facb208c08f.png

5d4c6812c8535adbb050f4ddf2e1bce8.png

为了防止发生非线程安全问题,还是应该继续使用同步方法。


4.currentThread()方法


该方法返回代码段正在被哪个线程调用的信息。


1.案例1


public class MyThread extends Thread{
    public MyThread() {
        System.out.println("构造方法的打印: "+ Thread.currentThread().getName());
    }
    @Override
    public void run() {
        System.out.println("run构造方法的打印: "+ Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png


改下:


public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
    }


均被main主线程所调用。


2.案例2:


public class CountOperate extends Thread{
    public CountOperate() {
        System.out.println("countOpera---begin");
        System.out.println("Thread.currentThread.getName()=" + Thread.currentThread().getName());
        System.out.println("this.getName()==" + this.getName());
        System.out.println("countOpera---end");
    }
    @Override
    public void run() {
        System.out.println("countOpera---begin");
        System.out.println("Thread.currentThread.getName()=" + Thread.currentThread().getName());
        System.out.println("this.getName()==" + this.getName());
        System.out.println("countOpera---end");
    }
    public static void main(String[] args) {
        CountOperate c = new CountOperate();
        Thread t1  = new Thread(c);
        t1.setName("A");
        t1.start();
    }
}


5.isAlive()方法


判断当前的线程是否是活跃的状态


public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("begin==" + this.isAlive());
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println("begin==" + myThread.isAlive());
        myThread.start();
        System.out.println("end==" + myThread.isAlive());
    }
}

1dc618a0ed9580ce8bfa6facb208c08f.png

5d4c6812c8535adbb050f4ddf2e1bce8.png

 

public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        System.out.println("begin==" + myThread.isAlive());
        myThread.start();
        Thread.sleep(1000);
        System.out.println("end==" + myThread.isAlive());
    }


6.sleep()方法



public class MyThread  extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("run threadName="+this.currentThread().getName() + " begin");
            Thread.sleep(2000);
            System.out.println("run threadName="+this.currentThread().getName() + " end");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println("begin = " + System.currentTimeMillis());
        myThread.start();
        System.out.println("end = " + System.currentTimeMillis());
    }
}



修改实验


public static void main(String[] args) {
        MyThread myThread = new MyThread();
        System.out.println("begin = " + System.currentTimeMillis());
        myThread.run();
        System.out.println("end = " + System.currentTimeMillis());
    }


6.getId()方法


public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getId() + "====" + thread.getName());
    }


当前线程的id为1,名字为main。


相关文章
|
1月前
|
Java 程序员
Java编程中的异常处理:从基础到高级
在Java的世界中,异常处理是代码健壮性的守护神。本文将带你从异常的基本概念出发,逐步深入到高级用法,探索如何优雅地处理程序中的错误和异常情况。通过实际案例,我们将一起学习如何编写更可靠、更易于维护的Java代码。准备好了吗?让我们一起踏上这段旅程,解锁Java异常处理的秘密!
|
16天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
20天前
|
算法 Java 调度
java并发编程中Monitor里的waitSet和EntryList都是做什么的
在Java并发编程中,Monitor内部包含两个重要队列:等待集(Wait Set)和入口列表(Entry List)。Wait Set用于线程的条件等待和协作,线程调用`wait()`后进入此集合,通过`notify()`或`notifyAll()`唤醒。Entry List则管理锁的竞争,未能获取锁的线程在此排队,等待锁释放后重新竞争。理解两者区别有助于设计高效的多线程程序。 - **Wait Set**:线程调用`wait()`后进入,等待条件满足被唤醒,需重新竞争锁。 - **Entry List**:多个线程竞争锁时,未获锁的线程在此排队,等待锁释放后获取锁继续执行。
54 12
|
17天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
100 2
|
17天前
|
NoSQL Redis
单线程传奇Redis,为何引入多线程?
Redis 4.0 引入多线程支持,主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作,以提高并发性和性能。尽管如此,Redis 仍保留单线程执行模型处理客户端请求,确保高效性和简单性。多线程仅用于优化后台任务,如异步删除过期对象和分担读写操作,从而提升整体性能。
46 1
|
1月前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####
|
1月前
|
Java 调度
Java中的多线程编程与并发控制
本文深入探讨了Java编程语言中多线程编程的基础知识和并发控制机制。文章首先介绍了多线程的基本概念,包括线程的定义、生命周期以及在Java中创建和管理线程的方法。接着,详细讲解了Java提供的同步机制,如synchronized关键字、wait()和notify()方法等,以及如何通过这些机制实现线程间的协调与通信。最后,本文还讨论了一些常见的并发问题,例如死锁、竞态条件等,并提供了相应的解决策略。
53 3
|
1月前
|
开发框架 安全 Java
Java 反射机制:动态编程的强大利器
Java反射机制允许程序在运行时检查类、接口、字段和方法的信息,并能操作对象。它提供了一种动态编程的方式,使得代码更加灵活,能够适应未知的或变化的需求,是开发框架和库的重要工具。
56 4
|
3月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
65 1
|
3月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
46 3
下一篇
开通oss服务