javaSE：不同方式线程创建；线程安全问题

f输入关键字

已于 2022-05-11 16:58:35 修改

阅读量397

点赞数

分类专栏： java_SE 文章标签： java 开发语言

于 2022-05-11 16:57:40 首次发布

本文链接：https://blog.csdn.net/m0_52338152/article/details/124713922

版权

java_SE 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1、线程基本知识：

/*
 1、并发并行：
	并发：两个或多个事件在同一时间段内发生
		多个事件交替执行
	并行：两个或多个事件在同一时刻发生
		多个事件同时执行
			并行速度快些
 2、进程与线程：
	线程属于进程，是进程的一个执行单元，负责程序的执行
	进程：点击程序，会进入内存中占用内存执行，进入到内存的程序叫做进程
	线程：点击程序功能执行，就会开启一条应用程序到cpu的执行路径，cpu就可以通过这个路径执行功能，该路径叫线程。
		cpu：中央处理器，对数据进行计算，指挥电脑中的软硬件干活
		 分类：AMD
			  Inter Inter Core(核心) i7 8866 	4核心8线程
				8线程可以同时执行8个任务
		单核心单线程cpu：cpu在多个线程之间高速切换，轮流执行多个线程，效率低，切换速度（1/n毫秒）
		4核心8线程cpu:可以同时执行8个线程，8个线程在多个人物之间做高速的切换，速度是单线cpu的8倍（每个任务执行到的几率被提高8倍）
		
		多线程好处：1、效率高	2、多个线程之间互不影响
 3、线程调度：
		分时调度：所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间
		抢占式调度：优先让优先级高的线程使用cpu【抢占cpu占用时间】，如果线程优先级相同，那么随机选择一个线程。【java使用抢占式调度】
		
 4、主线程：
		执行主方法（main）的线程
		单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行【出错后面就执行不了了】
		概念：JVM执行main方法进入到栈内存，JVM就会找操作系统开辟一条main方法通向cpu的执行路径，cpu就可以通过这个路径来执行main方法
																				这个路径就叫主（main）线程	
 */

2、Thread方式创建线程

/*
 创建多线程：
	方式1：
		创建Thread类的子类
		java.lang.Thread类，是描述线程的类
		实现：
			1、创建Thread类的子类
			2、在Thread的子类重写Thread类中的run方法，设置线程任务【开启线程要做什么】
			3、创建Thread类的子类对象
			4、调用Thread类的方法start方法，开启新的线程，执行run方法【中的任务】
			 public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 
			 结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和创建的新线程（执行其 run 方法）。
			 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。 
		java程序属于抢占式调度。
		主方法调用一次start()方法就是开辟新的栈空间，也就是增加一个线程，执行run()方法。多个线程互不影响。然后cpu就有了选择栈优先级的权利。
	
 */
 //方式1、
 public class Thread_lianxi extends Thread {
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("run:"+i);
        }
    }
}
public class Thread_lianxi01 {
    public static void main(String[] args) {
        Thread_lianxi t=new Thread_lianxi();
        t.start();	//和直接调用run方法，是有区别的【直接调用run（），是一个单线程】
        for(int i=0;i<5;i++){
            System.out.println("main:"+i);
        }
    }
}
//java使用抢占式调度，优先级相同，所以随机选一个先执行
main:0
run:0
main:1
run:1
main:2
run:2
main:3
run:3
main:4
run:4
 /*
* 一、获取线程的名称：
*   1、获取Thread类中的方法 String getName()
*   2、可以先获取当前正在执行的线程，使用线程中的方法getName()获取线程名称
*           static Thread currentThread() 返回对当前正在执行的线程对象的引用。
  二、设置线程名称【了解】：
	1、使用Thread类中的setName(线程名字)		void setName(String name) 改变线程名称，使之与参数 name 相同。 
	2、创建一个带参数的构造方法，参数传递线程名称；调用父类的带参构造方法，把线程名称传递给父类，让父类给子线程起一个名字。
												Thread(String name) 	分配新的 Thread 对象。
												
												
* */
//一
public class Thread_lianxi02 extends Thread {
    @Override
    public void run() {
        //1
       // String name = getName();
        //System.out.println(name);//Thread-0   Thread-1

        Thread th=new Thread();
        System.out.println(th);//Thread[Thread-2,5,main]    Thread[Thread-3,5,main]

        String name = th.getName();
        System.out.println(name);//Thread-3 Thread-2
        //2 链式编程
        System.out.println(Thread.currentThread().getName());//
        //Thread-2 Thread-0

    }
}
public class Thread_lianxi03 {
    public static void main(String[] args) {
        Thread_lianxi02 t=new Thread_lianxi02();
        t.start();

        new Thread_lianxi02().start();

        System.out.println(Thread.currentThread().getName());
        //main
    }
}
==
//二、
public class MyThread_lianxi extends Thread {
    public MyThread_lianxi(){}
    public MyThread_lianxi(String name){
        super(name);//将线程名称传递给父类，让父类给子线程起一个名字
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
 public class MyThread_lianxi01 {
    public static void main(String[] args) {
        MyThread_lianxi mt=new MyThread_lianxi();
        mt.setName("小强");
        mt.start();//小强

        new MyThread_lianxi("旺财").start();//旺财
    }
}

/*
	static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。 
		  */
public class sleep_lainxi {
    public static void main(String[] args) {
        for (int i = 0; i <=10; i++) {
            System.out.println(i);

            try {
                Thread.sleep(1000);//毫秒为单位 //【一秒打印一次i】
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3、Runnable接口方式创建线程

/*创建多线程
	方式2：
		实现Runnable接口
		java.lang.Runable
			Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。 
		java.lang.Thread类的构造方法：
			Thread(Runnable target)		分配新的 Thread 对象。 
			Thread(Runnable target, String name) 	分配新的 Thread 对象。 
		实现：			
			1、创建一个Runnable接口的实现类
			2、在实现类中重写Runnable接口的run方法，设置线程任务
			3、创建一个Runnable接口的实现类对象
			4、创建Thread类对象，构造方法中传递Runable接口的实现类对象
			5、调用Thread类中的start方法，开启新的线程执行run方法
实现Runnable接口创建多线程程序的好处：
	1、避免了单继承的局限性，一个类可以继承多个类
	2、降低了程序的耦合性，把设置线程任务和开启线程进行了分离（解耦）
		实现类中重写了run方法来设置线程任务；创建Thread类对象，开启了新的线程
		
*/
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 5; i++) {
            System.out.print(Thread.currentThread().getName()+"-->"+i);
        }
    }
}
public class main {
    public static void main(String[] args) {
        RunnableImpl run=new RunnableImpl();
        Thread t=new Thread(run);
        t.start();

        for (int i = 0; i <= 5; i++) {
            System.out.print(Thread.currentThread().getName()+"-->"+i);
        }
    }
}//main-->0Thread-0-->0main-->1Thread-0-->1main-->2Thread-0-->2main-->3Thread-0-->3main-->4Thread-0-->4main-->5Thread-0-->5

4、线程安全问题

4.1、同步代码块

/*
1、同步代码块
	原理：同步代码块传入锁对象，同步中的进程抢到CPU执行权后获取锁对象并执行，执行完后归还锁，不执行完不会释放锁；
	同步外的线程就算抢到CPU执行权，没有锁对象也不会进入同步。
		格式：synchronized(锁对象){
			//可能出现线程安全的代码【共享数据的代码】
		}
	注意：1、通过代码块中的锁对象，可以使用任意对象
			2、但是必须保证多个线程使用的锁对象是同一个
			3、锁对象作用：
				把同步代码块锁住，只让一个线程在同步代码块中执行
	缺点：频繁的判断锁，获取锁，释放锁，程序效率会降低。
 */
public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    //创建一个锁对象
    Object obj=new Object();
    @Override
    public 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+"张票");
                    ticket--;
                }
            }
        }
     }
}
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

4.2、synchronized修饰

/*2、同步方法：
	1、把访问了共享数据的代码抽取出来，放到一个方法中
	2、在方法上添加synchronized修饰符
	格式：定义方法的格式
	修饰符 synchronized 返回值类型 方法名(参数列表){
		访问了共享数据的代码
	}
	同步方法把方法里的代码锁住，只让一个线程执行；同步方法的锁对象是实现类对象r，也就是this
 */
 public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    @Override
    public void run() {
        while(true){
           payTicket();
            }
        }
        public synchronized void payTicket(){
            if(ticket>0){
                //因为使共享数据，为了提高线程安全问题出现概率，让程序睡眠一下，此时线程暂时失去程序的执行权
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

4.3、Lock锁

/*3、Lock锁
	3.1 java.util.concurrent.locks  Lock接口
		方法：void lock() 获取锁。 
		      void unlock() 释放锁。
		java.util.concurrent.locks.ReentrantLock implements Lock接口
			使用步骤：1、在成员位置创建一个ReentrantLock对象
					2、在可能会出现安全问题的代码前调用Lock接口中的方法lock() 获取锁
					3、在可能会出现安全问题的代码后调用Lock接口中的方法unlock() 获取锁
 */
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
	//1
    Lock l=new ReentrantLock();

    @Override
    public void run() {
        while(true){
			//2
            l.lock();

            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
			//3
            l.unlock();
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}
==
/*
3.2 最典型的代码如下： 
 class X {
   private final ReentrantLock l = new ReentrantLock();
   // ...

   public void m() { 
     l.lock();  // block until condition holds
     try {
       // ... 无论程序是否异常都可以
     } finally {
       lock.unlock()
     }
   }
 }

 */
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl_01 implements Runnable {
    private int ticket=100;
    Lock l=new ReentrantLock();

    @Override
    public void run() {
        while(true){
            l.lock();

            if(ticket>0){
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    l.unlock();//无论程序是否异常，都会把锁释放
                }
            }
            }
        }
     }
public class Ticket {
    public static void main(String[] args) {
        RunnableImpl_01 r=new RunnableImpl_01();
        Thread t0=new Thread(r);
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);
        t0.start();
        t1.start();
        t2.start();
    }
}

f输入关键字

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
javaSE：不同方式线程创建；线程安全问题

目录1、线程基本知识：2、Thread方式创建线程3、Runnable接口方式创建线程4、线程安全问题4.1、同步代码块4.2、synchronized修饰1、线程基本知识：/* 1、并发并行：并发：两个或多个事件在同一时间段内发生多个事件交替执行并行：两个或多个事件在同一时刻发生多个事件同时执行并行速度快些 2、进程与线程：线程属于进程，是进程的一个执行单元，负责程序的执行进程：点击程序，会进入内存中占用内存执行，进入到内存
复制链接

扫一扫