多线程
默认有main(用户线程) 和 g/c(垃圾回收器;守护线程)
三中创建方式:
jdk文档描述:创建一个新的线程有两种方法。一个是将一个类生命为Thread的子类。这个子类应该重写run类的方法Thread。然后可以分配并启动子类的实例。
狂神总结:
1.自定义线程类继承Thread类
2.重写run()方法,编写线程执行体
3.创建线程对象,调用start()方法启动线程
start方法是和主线程同时执行,run方法是看执行顺序
线程开启不一定立即执行,由CPU来调度
用Tread 来创建新线程:
package treat;
//此处为IO Commons的 jar包
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
public class TreatTes01 extends Thread{
private String url;
private String name;
public TreatTes01(String url, String name){
this.url = url;
this.name = name;
}
//下载图片线程的执行体
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,name);
System.out.println("下载了文件名为"+name);
}
public static void main(String[] args) {
TreatTes01 treatTes01 = new TreatTes01("http://bpic.588ku.com/element_origin_min_pic/16/08/19/1457b6a76c7756c.jpg","1");
TreatTes01 treatTes02 = new TreatTes01("http://bpic.588ku.com/element_origin_min_pic/16/10/29/2ac8e99273bc079e40a8dc079ca11b1f.jpg","2");
TreatTes01 treatTes03 = new TreatTes01("http://bpic.588ku.com/element_origin_min_785fde37639b.jpg","3");
treatTes01.start();
treatTes02.start();
treatTes03.start();
}
}
class WebDownloader{
//下载方法
public void downloader(String url, String name){
try {
FileUtils.copyURLToFile(new URL(url),new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常,downloader方法出现异常");
}
}
}
用Runnable 来创建新线程:
过程:1实现runnable接口
2.重写run方法
3.执行线程需要丢入runnable接口实现类
4.调用start方法
如图:
package treat;
public class ThreadTest02 implements Runnable{
//首先有10张票,每个人都可以拿
//先创建一个私有变量
private int ticket = 10;
@Override
public void run() {
while (true){
if(ticket<=0){
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿了第"+ticket--+"张票");
}
}
public static void main(String[] args) {
ThreadTest02 threadTest02 = new ThreadTest02();
new Thread(threadTest02,"小明").start();
new Thread(threadTest02,"小洪").start();
new Thread(threadTest02,"黄牛").start();
}
}
上图中的
Thread thread = new Thread(testThread3);
thread.start();
//==========================
//简写后为
new Thread(testThread3).start();
小结:
推荐使用Runnable接口,因为Java的单继承,方便同一个对象被多个线程使用
龟兔赛跑例子:
思路为:
代码为:
package treat;
public class Race implements Runnable{
private String winner;
@Override
public void run() {
for (int i = 0; i <=100; i++) {
//模拟兔子睡觉
if(Thread.currentThread().getName().equals("兔子")&&i%2==0){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag =gameOver(i);
//如果比赛结束了就停止程序
if(flag){
break;
}
System.out.println(Thread.currentThread().getName()+"---->"+"跑了"+i);
}
}
private Boolean gameOver(int steps){
//判断是否有胜利者
if(winner!= null){//已经存在胜利者
return true;
}{
if(steps>=100){
winner = Thread.currentThread().getName();
System.out.println("winner is "+ winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
callable(目前了解即可,未来公司有用)
callable 和 runnable的比较:
callable的好处:
可以定义返回值;
可以抛出异常。
静态代理
静态代理模式总结:
真实对象和代理对象都要实现同一个接口;
代理对象要代理真实角色。
好处:
代理对象可以做很多真实对象做不了的事情;
真实对象专注做自己的事情。
代码如下:
package treat;
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
}
interface Marry{
//人间四大喜事
//久旱逢甘露
//他乡遇故知
//洞房花烛夜
//金榜题名时
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry {
@Override
public void HappyMarry() {
{
System.out.println("秦老师要结婚了,可是新娘不是那个他的她");
}
}
}
//代理角色,帮助你去结婚
class WeddingCompany implements Marry{
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();
after();
}
private void after() {
System.out.println("结婚之后,收钱");
}
private void before() {
System.out.println("结婚之前,布置婚礼现场");
}
}
加入了lambda表达式后的代码,这里的HappyMarry 就是等于线程里的start。
package treat;
public class StaticProxy {
public static void main(String[] args) {
new Thread(()-> System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();
}
}
interface Marry{
//人间四大喜事
//久旱逢甘露
//他乡遇故知
//洞房花烛夜
//金榜题名时
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry {
@Override
public void HappyMarry() {
{
System.out.println("秦老师要结婚了,可是新娘不是那个他的她");
}
}
}
//代理角色,帮助你去结婚
class WeddingCompany implements Marry{
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();
after();
}
private void after() {
System.out.println("结婚之后,收钱");
}
private void before() {
System.out.println("结婚之前,布置婚礼现场");
}
}
lambda表达式
函数式接口的定义:
任何借口,如果只白喊唯一一个抽象方法,他就是一个函数式接口;
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。
lambda总结:
lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹;
前提是接口为函数式接口;
多个参数也可以去掉参数类型,要去掉就都去掉,必须加括号。
代码如下:
package lambda;
public class TestLambda01 {
public static void main(String[] args) {
ILove love = null;
love = (a,b)->{
System.out.println("i love you-->"+a);
System.out.println("i love you-->too");
};
love.love(520,502);
}
}
interface ILove{
void love(int a ,int b );
}
线程状态
线程方法:
停止线程:
代码如下:
package threadmethod;
//测试stop
//1.建议线程正常停止-->利用次数,不建议死循环
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable {
public static void main(String[] args) {
TestStop testStop =new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i );
if(i==900){
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("线程该停止了");
}
}
}
//设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("Thread.......runTime"+i++);
}
}
//设置一个公开的方法停止线程,转换标志位
public void stop(){
this.flag = false;
}
}
线程休眠
1000毫秒等于一秒;
每一个对象都有锁,sleep不会释放锁。
多个对象操作同一个线程就会引起安全问题;
模拟网络延时:方法问题的发生性;
线程休眠代码如下:
package threadmethod;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestSleep {
//模拟倒计时
public static void tenDown() throws InterruptedException {
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0){
break;
}
}
}
public static void main(String[] args) {
/*try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//打印当前时间
Date startTime = new Date(System.currentTimeMillis());//获取当前系统时间
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
线程礼让(yield)
礼让是本来a进去了,但是a礼让、他出来了。继续和b进行竞争,调度谁还是看cpu的心情
yield方法代码:
package threadmethod;
//测试礼让线程
//礼让不一定能够成功,看cpu心情
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"A").start();
new Thread(myYield,"B").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"线程结束执行");
}
}
Join
join代码如下:
package threadmethod;
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("VIP线程来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
//主线程
for (int i = 0; i < 1000; i++) {
if(i==200){
thread.join();//插队
}
System.out.println("Main"+i);
}
}
}
这里的插队有可能并发执行。没到200,VIP线程也会执行。
线程状态观测
join、sleep会让线程阻塞。
死亡之后的线程不能再次启动。
代码:
package threadmethod;
//观察测试线程的状态
public class TestState {
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("//");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);//new
//观察启动后
thread.start();//启动线程
state = thread.getState();//run
System.out.println(state);
while(state != Thread.State.TERMINATED){//只要线程不终止,就一直输出状态
state = thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
thread.start();
}
}
线程优先级
优先级并不能保证他绝对的在前面还是后面,具体的调度还是看cpu;这被称为性能倒置。
比如说a的优先级为10,b的优先级为3.只是说a被CPU调度的概率比b要大一些。
代码测试如下:
package threadmethod;
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread thread1 = new Thread(myPriority);
Thread thread2 = new Thread(myPriority);
Thread thread3 = new Thread(myPriority);
Thread thread4 = new Thread(myPriority);
Thread thread5 = new Thread(myPriority);
Thread thread6 = new Thread(myPriority);
//先设置优先级,再启动
thread1.start();
thread2.setPriority(1);
thread2.start();
thread3.setPriority(4);
thread3.start();
thread4.setPriority(Thread.MAX_PRIORITY);//最大值10
thread4.start();
/* thread5.setPriority(-1);
thread5.start();
thread6.setPriority(11);
thread6.start();
*/
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护线程(daemon)
代码实现如下:
package threadmethod;
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认为FALSE表示是用户线程,毕竟正常的线程都是用户线程
//God
//启动守护线程
thread.start();
new Thread(you).start();//你自己启动了(用户线程)
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝始终保佑着你");
}
}
}
//你自己
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你开心的活着每一天,你的那个她不在身边");
}
System.out.println("==========goodBye world=========");
}
}
守护线程:setdaemon默认为FALSE表示是用户线程,毕竟正常的线程都是用户线程。虚拟机不必等待守护线程结束,只需等待用户线程结束。
线程同步(重点加难点)
多个线程发访问同一个对象(并发),并且某些线程还想修改这个对象,这个时候我们就需要线程同步。线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
保证线程安全除了队列还需要锁 。
锁机制(synchronized),当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可。
但是会有问题:
核心:
不安全的线程实例:
不安全的列表:
package syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
//原因在于在同一时间有可能有多个对象同时占用同一个地方
不安全的买票:
package syn;
//不安全的买票
//会出现负数,线程不安安全
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"香茗").start();
new Thread(station,"上大").start();
new Thread(station,"打野").start();
}
}
class BuyTicket implements Runnable {
@Override
public void run() {
//买票
while(flag){
buy();
}
}
//票
private int ticketNums = 10;
private boolean flag = true;//外部停止方式
private void buy() {
if (ticketNums <= 0) {
flag = false;
return;
//买票
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
不安全的取钱:
package syn;
//不安全的取钱
//链各个人去银行取钱,账户
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "you");
Drawing she = new Drawing(account, 100, "she");
you.start();
she.start();
}
}
//账户
class Account{
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行:模拟取款
class Drawing extends Thread{
Account account;//账户
//取了多少钱
int drawingMoney;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account=account;
this.drawingMoney=drawingMoney;
}
@Override
public void run() {
//判断有没有钱
if (account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"你的账户余额不足");
return;
}
//sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 -你取的钱
account.money = account.money-drawingMoney;
//你手里的钱
nowMoney = nowMoney+drawingMoney;
System.out.println(account.name+"的余额为"+account.money);
//Thread.currentThread().getName()等价于this.getName.因为getName是Thread的方法,我们这里继承了他
//可以this.getName
System.out.println(this.getName()+"的手里的钱为"+nowMoney);
}
}
同步方法
同步块:
synchronized块锁的的是增删改查的东西,synchronized锁方法的时候是默认锁的this。
synchronized块的代码:
package syn;
//不安全的取钱
//链各个人去银行取钱,账户
public class UnsafeBank {
public static void main(String[] args) {
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "you");
Drawing she = new Drawing(account, 100, "she");
you.start();
she.start();
}
}
//账户
class Account{
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行:模拟取款
class Drawing extends Thread{
Account account;//账户
//取了多少钱
int drawingMoney;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
super(name);
this.account=account;
this.drawingMoney=drawingMoney;
}
//锁的对象就是变化的量,需要增删改的对象
@Override
public void run() {
synchronized(account){
//判断有没有钱
if (account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"你的账户余额不足");
return;
}
//sleep可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 -你取的钱
account.money = account.money-drawingMoney;
//你手里的钱
nowMoney = nowMoney+drawingMoney;
System.out.println(account.name+"的余额为"+account.money);
//Thread.currentThread().getName()等价于this.getName.因为getName是Thread的方法,我们这里继承了他
//可以this.getName
System.out.println(this.getName()+"的手里的钱为"+nowMoney);
}
}
}
synchronized锁方法的代码(默认就是锁的this,就是这个类):
package syn;
//不安全的买票
//会出现负数,线程不安安全
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"香茗").start();
new Thread(station,"上大").start();
new Thread(station,"打野").start();
}
}
class BuyTicket implements Runnable {
@Override
public void run() {
//买票
while(flag){
buy();
}
}
//synchronized 同步方法,锁的是this
//票
private int ticketNums = 10;
private boolean flag = true;//外部停止方式
private synchronized void buy() {
if (ticketNums <= 0) {
flag = false;
return;
//买票
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
锁的对象就是变化的量,需要增删改的对象。
synchronized安全的列表:
package syn;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
//原因在于在同一时间有可能有多个对象同时占用同一个地方
JUC并发包就是线程安全的包
这里是库里面实现的安全的列表:
package syn;
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
死锁
多个线程相互抱着对方的需要的资源,然后形成僵持
死锁的解决方案代码如下:
package threadmethod;
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0, "灰姑娘");
Makeup g2 = new Makeup(1, "白雪公主");
g1.start();
g2.start();
}
}
//镜子
class Mirror{
}
//口红
class Lipstick{
}
class Makeup extends Thread{
//需要的资源只有一份,用static来保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;//选择
String girlName;//使用化妆品的人
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if (choice == 0) {
synchronized (lipstick){
System.out.println(this.girlName+"获得口红的锁");
Thread.sleep(1000);//一秒后想获得镜子的锁
}//把这个锁拿到外面
synchronized (mirror){
System.out.println(this.girlName+"获得镜子的锁");
}
}else synchronized (mirror){
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(2000);//一秒后想获得口红的锁
}//把这个锁拿到外面
synchronized (lipstick){
System.out.println(this.girlName+"获得口红的锁");
}
}
}
lock(锁)
ReentrantLock(可重入锁)类实现了Lock。
代码格式如下:
代码测试(买票):
package threadmethod;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket).start();
new Thread(ticket).start();
new Thread(ticket).start();
}
}
class Ticket implements Runnable{
int ticketNums = 10;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();//加锁
if(ticketNums>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}
else
break;
}finally {
lock.unlock();//解锁
}
}
}
}
两种锁对比:
线程协作(生产者消费者模式)
线程通信:
一、this关键字主要有三个应用:
(1)this调用本类中的属性,也就是类中的成员变量;
(2)this调用本类中的其他方法;
(3)this调用本类中的其他构造方法,调用时要放在构造方法的首行。
Public Class Student {
String name; //定义一个成员变量name
private void SetName(String name) { //定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
}
应用一:引用成员变量
如上面这段代码中,有一个成员变量name,同时在方法中有一个形式参数,名字也是name,然后在方法中将形式参数name的值传递给成员变量name,虽然我们可以看明白这个代码的含义,但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name,还是反过来将成员变量name的值传递给形式参数name呢?也就是说,两个变量名字如果相同的话,那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。this这个关键字其代表的就是对象中的成员变量或者方法。也就是说,如果在某个变量前面加上一个this关键字,其指的就是这个对象的成员变量或者方法,而不是指成员方法的形式参数或者局部变量。为此在上面这个代码中,this.name代表的就是对象中的成员变量,又叫做对象的属性,而后面的name则是方法的形式参数,代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。
一般情况下,在Java语言中引用成员变量或者成员方法都是以对象名.成员变量或者对象名.成员方法的形式。不过有些程序员即使在没有相同变量的时候,也喜欢使用this.成员变量的形式来引用变量,这主要是从便于代码的阅读考虑的。一看到这个this关键字就知道现在引用的变量是成员变量或者成员方法,而不是局部变量。这无形中就提高了代码的阅读性。不过话说回来,这是this关键字在Java语言中的最简单的应用。从这个应用中,我们可以看出this关键字其代表的就是对象的名字。
其实如果是局部变量的话,也是相同的道理。如在上面的代码中,name不是形式参数,而是一个局部变量。此时Java也会遇到相同的疑惑,即变量名name代表的到底是局部变量还是形式参数?name=name到底代表的是什么含义?根据局部变量的作用域,在方法内部,如果局部变量与成员变量同名的话,那么是以局部变量为准。可是在name=name这个赋值语句中,将局部变量的值赋值给自己,显然并不是很合适。根据代码的含义,本来的意思应该是将局部变量赋值给成员变量。为了更清晰的表达这个含义,为此最好采用如下的书写格式this.name=name。这里的this关键字含义就是对象名student,为此this.name就表示student.name。
应用二:调用类的构造方法
public class Student { //定义一个类,类的名字为student。
public Student() { //定义一个方法,名字与类相同故为构造方法
this(“Hello!”);
}
public Student(String name) { //定义一个带形式参数的构造方法
}
}
this关键字除了可以调用成员变量之外,还可以调用构造方法。在一个Java类中,其方法可以分为成员方法和构造方法两种。构造方法是一个与类同名的方法,在Java类中必须存在一个构造方法。如果在代码中没有显示的体现构造方法的话,那么编译器在编译的时候会自动添加一个没有形式参数的构造方法。这个构造方法跟普通的成员方法还是有很多不同的地方。如构造方法一律是没有返回值的,而且也不用void关键字来说明这个构造方法没有返回值。而普通的方法可以有返回值、也可以没有返回值,程序员可以根据自己的需要来定义。不过如果普通的方法没有返回值的话,那么一定要在方法定义的时候采用void关键字来进行说明。其次构造方法的名字有严格的要求,即必须与类的名字相同。也就是说,Java编译器发现有个方法与类的名字相同才把其当作构造方法来对待。而对于普通方法的话,则要求不能够与类的名字相同,而且多个成员方法不能够采用相同的名字。在一个类中可以存在多个构造方法,这些构造方法都采用相同的名字,只是形式参数不同。Java语言就凭形式参数不同来判断调用那个构造方法。
在上面这段代码中,定义了两个构造方法,一个带参数,另一个没有带参数。构造方法都不会有返回值,不过由于构造方法的特殊性,为此不必要在构造方法定义时带上void关键字来说明这个问题。在第一个没有带参数的构造方法中,使用了this(“Hello!”)这句代码,这句代码表示什么含义呢?在构造方法中使this关键字表示调用类中的构造方法。如果一个类中有多个构造方法,因为其名字都相同,跟类名一致,那么这个this到底是调用哪个构造方法呢?其实,这跟采用其他方法引用构造方法一样,都是通过形式参数来调用构造方法的。如上例中,this关键字后面加上了一个参数,那么就表示其引用的是带参数的构造方法。如果现在有三个构造方法,分别为不带参数、带一个参数、带两个参数。那么Java编译器会根据所传递的参数数量的不同,来判断该调用哪个构造方法。从上面示例中可以看出,this关键字不仅可以用来引用成员变量,而且还可以用来引用构造方法。
不过如果要使用这种方式来调用构造方法的话,有一个语法上的限制。一般来说,利用this关键字来调用构造方法,只有在无参数构造方法中第一句使用this调用有参数的构造方法。否则的话,翻译的时候,就会有错误信息。这跟引用成员变量不同。如果引用成员变量的话,this关键字是没有位置上的限制的。如果不熟悉这个限制的话,那么还是老老实实的采用传统的构造方法调用方式为好。虽然比较麻烦,但是至少不会出错。
应用三:返回对象的值。
生产者消费者问题(管程解决方案)代码如下:
package gaoji;
//测试:生产者消费者模型-->利用缓冲区解决:管程法
//生产者,消费者,产品,缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container = container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了-->"+container.pop().id+"只鸡");
}
}
}
//产品
class Chicken{
int id ;
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken){
//如果容器满了通知消费者消费,生产者等待
if (count==chickens.length){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满,我们就需要丢入产品
chickens[count]=chicken;
count++;
//可以通知消费者消费了
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop(){
//判断能否消费
if (count ==0){
//等待生产者生产,消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count--;
Chicken chicken = chickens[count];
//吃完了,通知生产者生产
this.notifyAll();
return chicken;
}
}
生产者消费者问题解决方案二(标志位法)代码如下:
package gaoji;
//测试生产者消费者问题二
public class TestPC2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者-->演员
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if(i%2==0){
this.tv.play("快乐向前冲");
}else{
this.tv.play("刷抖音");
}
}
}
}
//消费者-->观众
class Watcher extends Thread{
TV tv;
public Watcher(TV tv) {
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
//产品-->节目
class TV{
//演员表演,观众等待 T
//观众观看,演员等待 F
String voice;
boolean flag = true;
//表演
public synchronized void play(String voice){
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了:"+voice);
//通知观众观看
this.notifyAll();//通知唤醒
this.voice = voice;
this.flag = !this.flag;
}
//观看
public synchronized void watch(){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了"+voice);
//通知演员表演
this.notifyAll();
this.flag = !this.flag;
}
}
线程池
线程池代码测试:
package gaoji;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
public static void main(String[] args) {
//创建服务,创建线程池
//newFixedThreadPool参数为池子的大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
线程总结:
线程总结代码如下:
package gaoji;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadNew {
public static void main(String[] args) {
//第一种启动方式
MyThread1 myThread1 = new MyThread1();
myThread1.start();//这两行等同于 new MyThread1().start
//第二种启动方式可以有多个线程
new Thread(new MyThread2()).start();
//第三种启动
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
new Thread(futureTask).start();
try {
Integer integer = futureTask.get();
System.out.println(integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1.继承Thread类
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println("MyThread1");
}
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("MyThread2");
}
}
//3.实现Callable 接口
class MyThread3 implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("MyThread3");
return 100;
}
}