java基础第十六篇之多线程

1:线程的概念 进程(任务):一个正在运行的程序 进程的调度:CPU来决定什么时候该运行哪个进程 (时间片轮流法) 线程在一个应用程序中,同时,有多个不同的执行路径,是进程中的实际运作单位。 好处是提高程序效率。

1.2 线程和进程的关系 a:一个进程可以创建多个线程 b:线程必须依赖于进程而存在 c:多个线程共享进程的空间 d:进程和线程得到CPU的机会是均等的‘ 1.3 为什么要搞多线程 我们可以让程序同时执行(并发执行)

//Java只让我们创建线程,而不让我们创建进程

HelloWorld.java
javac HelloWorld.java
java HelloWorld --->JVM 启动进程 
Run Application --->JVM 启动进程 

//一个进程中至少要有一个线程
main方法 被称为  主线程

2: 线程的创建方式 Thread 类 方式1:继承Thread类 1:自定义一个类,继承Thread类 2:重写Thread类的run方法 3:创建自定义类对象 4:让自定义类对象调用start方法,启动线程

  例题:
  package pack01_thread;

public class Demo01Thread {

public static void main(String[] args) {
	//3:创建自定义类对象
	MyThread mt = new MyThread();
	//4:让自定义类对象调用start方法,启动线程 
	mt.start();
	
	while(true){
		System.out.println("主线程");
	}
}

}

package pack01_thread;

//创建两个线程 public class Demo02Thread {

public static void main(String[] args) {
	MyThread mt1 = new MyThread();
	MyThread mt2 = new MyThread();
	mt1.start();
	mt2.start();
	
	while(true){
		System.out.println("主线程");
	}
}

}

package pack01_thread;

//创建两个线程 public class Demo03Thread {

public static void main(String[] args) {
	MyThread2 mt1 = new MyThread2();
	MyThread2 mt2 = new MyThread2();
	
	//设置线程的优先级 
	mt1.setPriority(Thread.MAX_PRIORITY);
	mt2.setPriority(Thread.MIN_PRIORITY);
	mt1.start();
	mt2.start();
}

}

package pack01_thread;

public class MyThread extends Thread { public void run() { while (true) { //获取线程的名字:getName System.out.println(getName() + “:线程”); } } }

package pack01_thread;

public class MyThread2 extends Thread { public void run(){ while(true){ //让线程睡眠一秒钟 //模拟网络延时 // try{Thread.sleep(1000);}catch(Exception e){} System.out.println(getName()+":子线程"); // Thread.yield(); } } }

  class MyThread extends Thread{
	  public void run(){
		//在此写你线程要执行的代码(木马查杀)
	  }
  }
  //-----------------
  MyThread mt = new MyThread();
  mt.start(); //启动线程----->系统会自动调用run方法


2.2 线程中的小方法
	public static void sleep(long millis)//线程执行到该语句,就会休眠---》让出CPU
	public static void yield() // 线程的礼让  线程执行到该语句 线程会将CPU的执行权主动让出
	                           // 让线程执行的更加均匀
	public final void setPriority(int newPriority) //设置线程的优先级

package pack02_thread;

public class Demo01Thread {

public static void main(String[] args) {
	MyRunnable mr = new MyRunnable();
	
	Thread t1 = new Thread(mr, "窗口1");
	Thread t2 = new Thread(mr, "窗口2");
	
	//给线程起名字

// t1.setName(“线程1”); // t2.setName(“线程2”); //这两个线程启动的时候,执行的都是MyRunnable中的run方法 t1.start(); t2.start();

	new Thread(mr,"窗口3").start(); //匿名对象创建
}

}

package pack02_thread;

public class Demo02Thread {

public static void main(String[] args) {
 
	//匿名内部类对象来创建线程
	new Thread(new Runnable() {
		
		@Override
		public void run() {
			while(true){
				System.out.println(Thread.currentThread().getName()+":线程");
			}
			
		}
	},"窗口").start();
}

}

package pack02_thread;

public class MyRunnable implements Runnable {

@Override
public void run() {
	while(true){
		//获取线程的名字
		//public static Thread currentThread() //当前线程对象
		System.out.println(Thread.currentThread().getName()+":子线程");
	}
}

}

package pack03_selltickets;

public class Demo01SellTickets {

public static void main(String[] args) {
	//模拟三个窗口来卖票 
	SellTickets st = new SellTickets();
	
	Thread t1 = new Thread(st, "窗口1");
	Thread t2 = new Thread(st, "窗口2");
	Thread t3 = new Thread(st, "窗口3");
	
	t1.start();
	t2.start();
	t3.start();
}

}

创建线程的方式二:实现接口Runnable
步骤 :
1:自定义类实现Runnable接口
2:重写run方法
3: 创建自定义对象
4:创建Thread类对象,并将自定义类对象作为参数传入Thread类
5: 通过Thread类对象调用start方法启动线程

class MyRunnable implements Runnable
{
	public void run(){
		//线程要执行的内容
	}
}

//----------------
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();//启动线程,系统会自动执行MyRunnable中的run方法

3: 线程的同步(线程的安全) a:同一张票被卖了多次 b:出现了负票问题

线程的同步有三种实现方法: a: 同步代码块 b: 同步方法 c: Lock锁

3.1 同步代码块 synchronized (锁对象) //可以是任何一个对象,必须保证线程共享这个对象 { //存放你要加锁的代码 } 3.2 同步方法 //同步方法的锁对象是this //静态方法的锁对象是类的Class对象 public synchronized void sellTickets(){ }

3.3 两者的区别 synchronized (锁对象) { xxxxx yyyyy zzzzz sssss ttttt }

public synchronized void sellTickets(){
	  xxxxx
	  yyyyy
	  zzzzz
	  sssss
	  ttttt	
}


//---------------
public void method(){
	xxxxx
	yyyyy
	synchronized (锁对象)  {
		zzzzz
		sssss
		ttttt	
	}
}
//同步方法,用户不能只指定锁对象,默认都是this
//同步代码块,自己可以指定锁对象,锁对象可以是任何对象,只要线程共享即可

3.4 Lock锁 Lock: ReentrantLock lock(); 加锁 unlock(); 解锁

1:创建ReentrantLock对象 2:在适当的地方加锁 lock() 2:在适当的地方解锁 unlock();

package pack03_selltickets;

public class SellTickets implements Runnable {

//模拟100张票
int tickets = 100;
//创建一个锁对象
Object obj = new Object();
//模拟卖票
@Override
public void run() {
	while(true){
		//将if代码块进行了加锁
		//T1 T2
		synchronized (obj) {
			if(tickets > 0){
				//会发生网络延时
				try {Thread.sleep(50);} catch (InterruptedException e) {}
				System.out.println(Thread.currentThread().getName()+"正在出售第" 
			    + (tickets--)+"张票");
			}
		}
		
	}
}

}

package pack05_selltickets;

public class Demo01SellTickets {

public static void main(String[] args) {
	//模拟三个窗口来卖票 
	SellTickets st = new SellTickets();
	
	Thread t1 = new Thread(st, "窗口1");
	Thread t2 = new Thread(st, "窗口2");
	Thread t3 = new Thread(st, "窗口3");
	
	t1.start();
	t2.start();
	t3.start();
}

}

package pack06_selltickets;

import java.util.Scanner;

public class Demo01SellTickets {

@SuppressWarnings("resource")
public static void main(String[] args) {

// //模拟三个窗口来卖票 // SellTickets st = new SellTickets(); // // Thread t1 = new Thread(st, “窗口1”); // Thread t2 = new Thread(st, “窗口2”); // Thread t3 = new Thread(st, “窗口3”); // // t1.start(); // t2.start(); // t3.start(); String num = new Scanner(System.in).nextLine(); }

}

package pack07_selltickets;

import java.util.Scanner;

public class Demo01SellTickets {

public static void main(String[] args) {
	new Thread(new SellTickets(true)).start();;
	new Thread(new SellTickets(false)).start();;
}

}

package pack07_selltickets;

//证明死锁

//方式1:用筷子左和筷子右证明死锁 package com.baidu_01;

public class Demo5_DeadLock { //这是两把锁 private static String s1 = “筷子左”; private static String s2 = “筷子右”; public static void main(String[] args) { new Thread() { public void run() { while(true) { synchronized(s1) {

					System.out.println(getName() + "获取" + s1 + "等待" + s2);
					synchronized(s2) {
						System.out.println(getName() + "拿到" + s2 + "开吃");
					}
					
					
				}
			}
		}
	}.start();
	
	
	new Thread() {
		public void run() {
			while(true) {
				synchronized(s2) {
					System.out.println(getName() +"获取" + s2 + "等待" + s1);
					synchronized(s1) {
						System.out.println(getName() +"拿到" + s1 + "开吃");
					}
				}
			}
		}
	}.start();
	
}

}

//方式2 class MyLock{ public static Object lockA = new Object(); public static Object lockB = new Object(); } public class SellTickets implements Runnable {

boolean bl;

public SellTickets() {
}

public SellTickets(boolean bl) {
	this.bl = bl;
}

@Override
public void run() {
	if(bl){
		//T1线程
		synchronized (MyLock.lockA) { //T1得到A
			System.out.println(Thread.currentThread().getName()+":得到lockA");
			synchronized (MyLock.lockB) {
				System.out.println(Thread.currentThread().getName()+":得到lockA和lockB");
			}
		}
	}else{
		//T2线程
		synchronized (MyLock.lockB) { //T2得到B
			System.out.println(Thread.currentThread().getName()+":得到lockB");
			synchronized (MyLock.lockA) {
				System.out.println(Thread.currentThread().getName()+":得到lockB和lockA");
			}
		}
	}
}

} 线程的生命周期: 新建:创建线程对象. 就绪状态:有执行的资格,没有执行权. 运行状态:有执行资格,也有执行权. 阻塞状态 : 没有执行资格,没有执行权. 死亡状态:代码执行完毕,线程消亡.

											运行 -- (run结束或者stop()) -- 死亡(线程对象变成垃圾)
新建 -(start())-- 就绪 -(抢到了CPU的执行权)-运行 --(sleep()和wait()) --阻塞 -- 就绪状态
					运行-(被其他的线程把CPU的执行权给抢走了) -- 就绪

单例设计模式:

package pack08_singleobject;

//懒汉式 public class Worker { private Worker(){}

private static Worker worker = null;
public static synchronized Worker getWorker(){ //
	if(worker == null){ 
		//T1 T2 T3 
		worker = new Worker();
	}
	return worker;
}

}

package pack08_singleobject;

//饿汉式 //一个类只允许创建一个对象 public class Student { //构造方法私有 private Student(){}

//自己创建对象
private static Student stu = new Student();
//对外提供对象
public static Student getStudent(){
	return stu;
}

}

package pack08_singleobject;

import java.io.IOException;

public class TestDemo { public static void main(String[] args) throws IOException { // Student stu1 = Student.getStudent(); // Student stu2 = Student.getStudent(); // // System.out.println(stu1 == stu2); Runtime rt = Runtime.getRuntime();

	rt.exec("QQ");
}

}

创建线程第三种方法:

(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。 (在Thread线程不能直接和Callable进行使用,所以用子类进行连接) (2)创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。 (在FutureTast的构造方法里面有一个可以传入Callable接口的方法,这样就把封装Callable对象了,并且封装了Callable的Call()方法的返回值) (3)使用FutureTask对象作为Thread对象的target创建并启动新线程。(用了Thread对象的构造方法可以传入Runnable接口,而Future又是Runnable的接口的实现类)

(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

Callable方法的好处:有返回值,可以抛异常.(Runnable不可以抛异常和不能有返回值)

例题: package com.baidu_01;

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future;

public class Demo6_Callable {

public static void main(String[] args) throws InterruptedException, ExecutionException {
	//创建线程池
	ExecutorService pool = Executors.newFixedThreadPool(2);
	//将线程放进池子里并执行
	Future<Integer> f1  = pool.submit(new MyCallable(100));
	Future<Integer> f2 = pool.submit(new MyCallable(50));
	
	System.out.println(f1.get());
	
	System.out.println(f2.get());
	
	pool.shutdown();
	
	
}

}

class MyCallable implements Callable {

private int num;
public MyCallable(int num) {
	this.num = num;
}

@Override
public Integer call() throws Exception {
	// TODO Auto-generated method stub
	
	int sum = 0;
	for(int i = 0 ; i <= num ; i++) {
		sum += i;
	}
	
	return sum;
}

}

package com.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
public class CallableThreadTest implements Callable<Integer>  
{  
  
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值:"+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }  
  
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
  
}  


package com.thread;  
  
import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
  
public class CallableThreadTest implements Callable<Integer>  
{  
  
    public static void main(String[] args)  
    {  
	
		MyRunnable mt = new MyRunnable();
		
		Thread t1 = new Thread(mt);
	
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
              Thread  target =  new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值:"+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }  
  
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
  
}  

class MyRunnalbe implements Runnable { public void run() {

}

}

二、创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时,优势是:

线程类只是实现了Runnable接口或Callable接口,还可以继承其他类。

在这种方式下,多个线程可以共享同一个target对象,所以非常适合多个相同线程来处理同一份资源的情况,从而可以将CPU、代码和数据分开,形成清晰的模型,较好地体现了面向对象的思想。

劣势是:

编程稍微复杂,如果要访问当前线程,则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是:

编写简单,如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。

劣势是:

线程类已经继承了Thread类,所以不能再继承其他父类。

非静态的同步方法的锁对象是神马? * 答:非静态的同步方法的锁对象是this * 静态的同步方法的锁对象是什么? * 是该类的字节码对象.

//锁对象不能用匿名对象,因为匿名对象不是同一个对象

ipconfig:在DOS查看本机IP地址.

从 Java 5 开始,Java 提供了自己的线程池。线程池就是一个线程的容器,每次只执行额定数量的线程。 java.util.concurrent.ThreadPoolExecutor 就是这样的线程池。它很灵活,但使用起来也比较复杂,本文就对其做一个介绍。 首先是构造函数。以最简单的构造函数为例: public ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) 看起来挺复杂的。这里介绍一下。 corePoolSize 指的是保留的线程池大小。 maximumPoolSize 指的是线程池的最大大小。 keepAliveTime 指的是空闲线程结束的超时时间。 unit 是一个枚举,表示 keepAliveTime 的单位。 workQueue 表示存放任务的队列。 我们可以从线程池的工作过程中了解这些参数的意义。线程池的工作过程如下: 1、线程池刚创建时,里面没有一个线程。任务队列是作为参数传进来的。不过,就算队列里面有任务,线程池也不会马上执行它们。

2、当调用 execute() 方法添加一个任务时,线程池会做如下判断: a. 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务; b. 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入队列。 c. 如果这时候队列满了,而且正在运行的线程数量小于 maximumPoolSize,那么还是要创建线程运行这个任务; d. 如果队列满了,而且正在运行的线程数量大于或等于 maximumPoolSize,那么线程池会抛出异常,告诉调用者“我不能再接受任务了”。

3、当一个线程完成任务时,它会从队列中取下一个任务来执行。

4、当一个线程无事可做,超过一定的时间(keepAliveTime)时,线程池会判断,如果当前运行的线程数大于 corePoolSize,那么这个线程就被停掉。所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。

这样的过程说明,并不是先加入任务就一定会先执行。假设队列大小为 10,corePoolSize 为 3,maximumPoolSize 为 6,那么当加入 20 个任务时,执行的顺序就是这样的:首先执行任务 1、2、3,然后任务 4~13 被放入队列。这时候队列满了,任务 14、15、16 会被马上执行,而任务 17~20 则会抛出异常。最终顺序是:1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子: public static void main(String[] args) { BlockingQueue queue = new LinkedBlockingQueue(); ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);

for (int i = 0; i < 20; i++) { executor.execute(new Runnable() {

  public void run() { 
    try { 
      Thread.sleep(1000); 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
    System.out.println(String.format("thread %d finished", this.hashCode())); 
  } 
}); 

} executor.shutdown(); } 对这个例子的说明如下:

1、BlockingQueue 只是一个接口,常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话,因为队列不会满,所以 execute() 不会抛出异常,而线程池中运行的线程数也永远不会超过 corePoolSize 个,keepAliveTime 参数也就没有意义了。

2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后,主线程就马上结束了,而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法,那么线程池会一直保持下去,以便随时添加新的任务。

到这里对于这个线程池还只是介绍了一小部分。ThreadPoolExecutor 具有很强的可扩展性,不过扩展它的前提是要熟悉它的工作方式。后面的文章将会介绍如何扩展 ThreadPoolExecutor 类。 ava.util.concurrent.ThreadPoolExecutor 类提供了丰富的可扩展性。你可以通过创建它的子类来自定义它的行为。例如,我希望当每个任务结束之后打印一条消息,但我又无法修改任务对象,那么我可以这样写: ThreadPoolExecutor executor = new ThreadPoolExecutor(size, maxSize, 1, TimeUnit.DAYS, queue) { @Override protected void afterExecute(Runnable r, Throwable t) { System.out.println(“Task finished.”); } };

除了 afterExecute 方法之外,ThreadPoolExecutor 类还有 beforeExecute() 和 terminated() 方法可以重写,分别是在任务执行之前和整个线程池停止之后执行。

除了可以添加任务执行前后的动作之外, ThreadPoolExecutor 还允许你自定义当添加任务失败后的执行策略。你可以调用线程池的 setRejectedExecutionHandler() 方法,用自定义的 RejectedExecutionHandler 对象替换现有的策略。 ThreadPoolExecutor 提供 4 个现有的策略,分别是: ThreadPoolExecutor.AbortPolicy:表示拒绝任务并抛出异常 ThreadPoolExecutor.DiscardPolicy:表示拒绝任务但不做任何动作 ThreadPoolExecutor.CallerRunsPolicy:表示拒绝任务,并在调用者的线程中直接执行该任务 ThreadPoolExecutor.DiscardOldestPolicy:表示先丢弃任务队列中的第一个任务,然后把这个任务加进队列。 这里是一个例子: ThreadPoolExecutor executor = new ThreadPoolExecutor(size, maxSize, 1, TimeUnit.DAYS, queue); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy()); 除此之外,你也可以通过实现 RejectedExecutionHandler 接口来编写自己的策略。下面是一个例子: ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.SECONDS, queue, new RejectedExecutionHandler() { public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.out.println(String.format(“Task %d rejected.”, r.hashCode())); } } );

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券