Java基础_多线程2

最新推荐文章于 2024-03-10 23:38:03 发布
最新推荐文章于 2024-03-10 23:38:03 发布
阅读量384 收藏
点赞数
分类专栏： Java基础特性 文章标签： java thread string 多线程 exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangcheng91/article/details/7852902
版权

一、多线程(线程间通信-示例代码)

/*
线程间通讯：
其实就是多个线程在操作同一个资源，但是操作的动作不同。
*/
class Res
{
	String name;
	String sex;
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			if(x==0)
			{
				r.name="mike";
				r.sex="男";
			}
			else
			{
				r.name="lili";
				r.sex="女";
			}
			x=(x+1)%2;		
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			System.out.println("姓名："+r.name+"\t"+"性别："+r.sex);
		}
	}
}
class InputOutputDemo 
{
	public static void main(String[] args) 
	{
		Res r=new Res();
		Input in=new Input(r);
		Output out=new Output(r);

		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		t1.start();
		t2.start();
	}
}


二、多线程(线程间通信-解决安全问题)

/*
线程间通讯：
其实就是多个线程在操作同一个资源，但是操作的动作不同。
*/
class Res
{
	String name;
	String sex;
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			synchronized(r)//Input.class也可以
			{
				if(x==0)
				{
					r.name="mike";
					r.sex="男";
				}
				else
				{
					r.name="lili";
					r.sex="女";
				}
				x=(x+1)%2;
			}
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				System.out.println("姓名："+r.name+"\t"+"性别："+r.sex);
			}
		}
	}
}
class InputOutputDemo 
{
	public static void main(String[] args) 
	{
		Res r=new Res();
		Input in=new Input(r);
		Output out=new Output(r);

		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		t1.start();
		t2.start();
	}
}


三、多线程(线程间通信-等待唤醒机制)

wait():

notify():

notifyAll():

都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义在Object类中呢？

因为这些方法在操作同步中线程时，都必须要表示它们所操作线程只有的锁，只有同一个锁上的被等待线程，才可以被同一个上notify唤醒。也就是说等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

/*
线程间通讯：
其实就是多个线程在操作同一个资源，但是操作的动作不同。
*/
class Res
{
	String name;
	String sex;
	boolean flag=false;
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			if(r.flag)
				try{r.wait();}catch(Exception e){}//存入线程池中
			synchronized(r)//Input.class也可以
			{
				if(x==0)
				{
					r.name="mike";
					r.sex="男";
				}
				else
				{
					r.name="lili";
					r.sex="女";
				}
				x=(x+1)%2;

				r.flag=true;
				r.notify();//唤醒线程池中的线程。（第一个存放的，例如队列）
			}
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				if(!r.flag)
					try{r.wait();}catch(Exception e){}//存入线程池中
				
				System.out.println("姓名："+r.name+"\t"+"性别："+r.sex);

				r.flag=false;
				r.notify();//唤醒线程池中的线程。（第一个存放的，例如队列）
			}
		}
	}
}
class InputOutputDemo 
{
	public static void main(String[] args) 
	{
		Res r=new Res();
		Input in=new Input(r);
		Output out=new Output(r);

		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		t1.start();
		t2.start();
	}
}


四、多线程(线程间通信-代码优化)

/*
优化：
*/
class Res
{
	private String name;
	private String sex;
	private boolean flag=false;

	public synchronized void set(String name,String sex)
	{
		if(flag)
			try{this.wait();}catch(Exception e){}//存入线程池中

		this.name=name;
		this.sex=sex;
		
		flag=true;
		this.notify();
		
	}
	public synchronized void out()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}//存入线程池中

		System.out.println("姓名："+this.name+"\t"+"性别："+this.sex);

		flag=false;
		this.notify();//唤醒线程池中的线程。（第一个存放的，例如队列）


	}
}
class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			if(x==0)
			{
				r.set("maike","男");
					
			}
			else
			{
				r.set("lili","女");
			}
			x=(x+1)%2;
		}
	}
}
class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}
class InputOutputDemo 
{
	public static void main(String[] args) 
	{	Res r=new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
	}
}


五、多线程(线程间通信-生产者消费者)

/*
生产者消费者：
*/
class ProducerConsumerDemo 
{
	public static void main(String[] args) 
	{
		Resource r=new Resource();

		Producer pro=new Producer(r);
		Consumer con=new Consumer(r);

		Thread t1=new Thread(pro);
		Thread t2=new Thread(con);

		t1.start();
		t2.start();
	}
}

class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;

	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name=name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		
		flag=true;
		this.notifyAll();
	}
	public synchronized void out()
	{
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
		
		flag=false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品+");
		}
	}
}
class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			res.out();
		}
	}

}


说明:

对于多个生产者和消费者，为什么要定义while判断标记？

原因：让被唤醒的线程再一次判断标记。

为什么定义notityAll ?

因为需要唤醒对方线程，只用notify容易唤醒本方线程的情况，导致程序中的所有线程都等待。

六、多线程(线程间通信-生产者消费者JDK5.0升级版)

/*
JDK1.5中提供了多线程升级解决方案。（显式锁机制）
将同步Synchronized替换成实现Lock操作。
将Object中的wait,notify,notifyAll替换成Condition对象。
该对象可以通过Lock锁的newCondition()进行获取。

在该示例中，实现了本方只唤醒对方的操作。

*/

import java.util.concurrent.locks.*;
class ProducerConsumerDemo 
{
	public static void main(String[] args) 
	{
		Resource r=new Resource();

		Producer pro=new Producer(r);
		Consumer con=new Consumer(r);

		Thread t1=new Thread(pro);
		Thread t2=new Thread(con);
		Thread t3=new Thread(pro);
		Thread t4=new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}


class Resource
{
	private String name;
	private int count=1;
	private boolean flag=false;

	private Lock lock=new ReentrantLock();
	private Condition condition_pro=lock.newCondition();//生产
	private Condition condition_con=lock.newCondition();//消费

	public  void set(String name)throws InterruptedException
	{
		lock.lock();//加锁
		try
		{
			while(flag)
				condition_pro.await();//挂起线程

			this.name=name+"--"+count++;

			System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		
			flag=true;
		
			condition_con.signal();//唤醒线程
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行。
		}	
	}
	public  void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();

			System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
		
			flag=false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}
class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res=res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}

}


七、多线程(停止线程)

/*
stop 方法已经过时，如何停止进程？
只有一种，run方法结束。
开启多线程运行，运行代码通常都是循环结构，只要控制住循环，就可以
让run方法结束，也就是线程结束。


特殊情况：
当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时就需要对冻结进行清除，
强制让线程回复到运行状态中来，这样就可以操作标记，让线程结束。
Thread类中提供了该方法interrupt();

*/
class StopThread implements Runnable
{
	private boolean flag=true;

	public synchronized void run()
	{
		while(flag)
		{
			try
			{
				this.wait();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName()+"....Exception");
				flag=false;
			}
			System.out.println(Thread.currentThread().getName()+"....run");
		}
	}
	public void changeFlag()
	{
		flag=false;
	}
}
class StopThreadDemo 
{
	public static void main(String[] args) 
	{
		StopThread st=new StopThread();
		Thread t1=new Thread(st);
		Thread t2=new Thread(st);

		t1.start();
		t2.start();

		int num=0;

		while(true)
		{
			if(num++==60)
			{
				//st.changeFlag();
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"....."+num);
		}
		System.out.println("结束");
	}
}


八、多线程(守护线程)

public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 

该方法必须在启动线程前调用。 

该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。 

参数：

on - 如果为 true，则将该线程标记为守护线程。 

一句话总结：守护线程类似于保镖，“保护”其它非守护线程，一旦非守护线程结束，这个“保镖”也就没有存在的意义，所以会守护线程在这时也会结束。

九、多线程(Join方法)

public final void join()

                throws InterruptedException

等待该线程终止。 

抛出： 

InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。

当A线程执行到了B线程的join方法时，A线程就会等待B线程都执行完，A才会执行。

所以，join可以用来临时加入线程的执行。

/*
join:
*/
class Demo implements Runnable
{
	public void run()
	{
		for(int i=0;i<70;i++)
		{
			System.out.println(Thread.currentThread().getName()+"..."+i);
		}
	}
}
class  JoinDemo
{
	public static void main(String[] args) throws Exception
	{
		Demo d=new Demo();
		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		t1.start();

		t1.join();

		t2.start();

		for(int i=0;i<80;i++)
		{
			System.out.println("main..."+i);
		}
		System.out.println("结束");
	}
}


十、多线程(优先级和yield方法)

优先级：线程被执行的优先级别。

public final void setPriority(int newPriority)更改线程的优先级。 

首先调用线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException。 

在其他情况下，线程优先级被设定为指定的 newPriority 和该线程的线程组的最大允许优先级相比较小的一个。 

参数：

newPriority - 要为线程设定的优先级 

抛出： 

IllegalArgumentException - 如果优先级不在 MIN_PRIORITY 到 MAX_PRIORITY 范围内。 

SecurityException - 如果当前线程无法修改该线程。

yield方法：

public static void yield()暂停当前正在执行的线程对象，并执行其它线程。

 

 

/*
多线程的应用：
*/
class ThreadTest 
{
	
	public static void main(String[] args) 
	{
		new Thread()
		{
			public void run()
			{
				for(int i=0;i<100;i++)
				{
					System.out.println(Thread.currentThread().getName()+"..."+i);
				}
			}
		}.start();
		

		for(int i=0;i<100;i++)
		{
			System.out.println(Thread.currentThread().getName()+"..."+i);
		}

		
		new Thread(new Runnable()
		{
			public void run()
			{
				for(int i=0;i<100;i++)
				{
					System.out.println(Thread.currentThread().getName()+"..."+i);
				}	
			}
		}).start();
		
	}
}

yangcheng91
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程基础（二）
张毅的博客
06-03 187
java多线程基础（二）1.ThreadLocal1.2 ThreadLocal原理1.3 ThreadLocal 内存泄露问题 1.ThreadLocal ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。 ThreadLocal 是 JDK java.lang 包中的一个用来实现相同线程数据共享不同的线程数据隔离的一个工具。 如果你创建了
Java基础--多线程
weixin_33407107的博客
05-26 72
什么是线程 进程的概念 进程是指可执行程序并存放在计算机存储器的一个指令序列，他是一个动态执行的过程 线程是比进程还要小的运行单位，一个进程包含多个线程 通过对cpu的轮转，来实现系统的多进程。一个软件用1ms cpu轮流使用 什么是多线程 线程的创建 创建一个Thread类，或者一个Thread子类的对象 创建一个实现Runnable接口类的对象 Thread类 是一个线程类，在java.lang包下 Thread类的常用方法 class myThread extends.
多线程之间实现通讯
weixin_30407099的博客
01-24 88
多线程之间实现通讯 课程目标 多线程之间如何通讯 wait、notify、notifyAll()方法 lock 停止线程 多线程之间如何实现通讯 什么是多线程之间通讯？ 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 画图演示 多线程之间通讯需求 需求:第一个线程写入(input)用户，另一个线程取读取(out)用户.实现读一个，写一...
程序员必会的Java多线程与并发编程
Mr_wxc的博客
04-26 2682
1、线程三大特性 多线程有三大特性：原子性、可见性、有序性 原子性： 即一个操作或者多个操作，要么全部执行成功，要么全都不执行。 一个很经典的例子就是银行账户转账问题： 比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。这2个操作都必须要具备原子性才能保证转账成功，而不会出现一些意外的情况。 可见性： 当多个线程访问同一个变量时，如果一个线程修...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
最新发布
qq_35716689的博客
03-10 24万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
ss.rar_java apple_多线程 java_接力赛跑_赛跑 java
09-21
在实际编程中，开发者需要理解如何创建和管理线程，以及如何利用同步机制确保线程安全，这些都是Java多线程编程的基础。通过这样的练习，可以加深对并发编程的理解，提高编写高并发应用的能力。
java基础代码_java_输入输出流_接口_多线程_异常_
09-29
总结一下，Java基础代码的学习涵盖了输入输出流的使用，如何通过接口定义和实现类的行为规范，多线程的创建与管理，以及异常处理的策略。这些内容构成了Java程序员的基本技能，对于初学者来说至关重要。深入理解并...
TCP.rar_java Tcp _tcp java_tcp 多线程_tcp多线程
09-23
Java作为一种强大的编程语言，提供了丰富的API来支持TCP编程，使得开发者能够轻松地创建多线程TCP连接。本文将深入探讨如何使用Java实现多线程TCP连接，并涉及相关的关键知识点。 首先，TCP是一种面向连接的、可靠...
Download_Java.rar_多线程 下载_多线程下载
09-19
在Java编程中，多线程是一项关键技能，它允许程序同时执行多个任务，极大地提高了效率。...通过分析和实践这个示例，你可以掌握多线程编程的核心概念，提高处理并发问题的能力，并为构建更加高效的应用打下坚实的基础。
Java基础_网络编程相关小项目
杨成的专栏
08-26 1514
一、网络编程(TCP-上传图片) /* 需求：上传图片。 */ /* 客户端： 1.服务端点。 2.读取客户端已有的图片数据。 3.通过socket输出流将数据发给服务端。 4.读取服务端反馈信息。 5.关闭。 */ import java.net.*; import java.io.*; class PicClient { public static void main(String[
Java基础_面向对象（继承、子父类变量和函数以及构造函数特点、final关键字、抽象类、模版方法模式、接口）
杨成的专栏
08-02 1483
一、面向对象（继承） 继承： 1.提高了代码的复用性。 2.让类与类之间产生了关系。有了这个关系，才有了多态的特性。   注意：千万不要为了获取其它类的功能，而简化代码进行继承。必须是类与类之间有所属关系才可以继承。   /* 将学生和工人的共性描述提取出来，单独进行描述。 */ class Person//人类（父类） { String name; int age; } cl
Java基础_面向对象（Static的使用、对象初始化和调用成员过程、单例设计模式）
杨成的专栏
08-01 1380
一、面向对象（static关键字） static:用于修饰成员（成员变量，成员函数） 当成员被静态关键字修饰后，就多了一个调用方式，除了可以被对象调用外还可以直接被类名调用。例：类名.静态成员   static存储在静态存储区，当程序执行，类的代码被加载到内存，类的静态变量就分配了内存空间，它是属于类的，也就是每个实例对象都是对应一个静态变量，静态变量的内存空间直到程序退出才释放所占用的内
Java基础_面向对象（异常2、练习题、导包）
杨成的专栏
08-09 1338
一、面向对象（异常-finally） finally代码块：定义一定要执行的代码，通常用于关闭资源。 /* 举例：操作数据库。 1.连接 2.操作 3.关闭 */ import java.sql.SQLException;//引入SQL包的SQLException类 class NoException extends Exception { NoException(String msg)
Java基础_IO流（对象序列化和字符编码）
杨成的专栏
08-22 1330
一、IO流(对象的序列化) 对象流：ObjectInputStream和ObjectOutputStream（实现对象序列化） 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说(就是I/O)，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！在对对象流进行读写操作时会引发一些问题，而序
Java基础_IO流（File类和properties类相关操作）
杨成的专栏
08-21 861
一、IO流(File概述) File类： 用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。 File对象可以作为参数传递给流的构造函数。 /* File概述: */ import java.io.*; class FileDemo { public static void main(String[] args) { consMethod();
Java基础_面向对象(概述、类与对象关系、成员变量、封装private、构造函数和构造代码块、this关键字)
杨成的专栏
07-31 831
一、面向对象（类和对象的关系） 面向对象的三个特征：封装，继承，多态。 以后开发：找对象，建立对象，使用对象，维护对象的关系。   类和对象的关系：类是对象的抽象，对象是类的具体实现。   现实生活中的对象：张三，李四。 描述：提取对象中的共性内容。对具体的抽象。 描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。 映射到java中，描述就是class定义的类。 集
Java基础_常用基础内容（进制转换、基本数据类型、运算符、流程控制语句等）
杨成的专栏
07-27 817
一、进制转换 参考这篇文章： 二进制、八进制、十进制、十六进制之间转换 注意： 负数的二进制表现形式： 6= 110   -6：其实就是6的二进制取反+1 取反：将二进制的1变成0，将0变成1。       0000-0000  0000-0000   0000-00000  000-0110                （二进制6）        1111-1111  1
Java基础_String类
杨成的专栏
08-12 726
一、String(概述) /* String概述： */ class StringDemo { public static void main(String[] args) { String s1="abc";/*s1是一个类类型变量，"abc"是一个对象。 字符串最大特点：一旦被初始化就不可改变。 "abc"存在常量池中。 */ Strin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值