javautil源码

发布时间: 2022-09-06 03:18:19

1. java 源代码（if语句）

importjava.util.Scanner;

publicclasstest{
	publicstaticvoidmain(String[]args){
		intj=0;//从0米开始跑
		Scannerin=newScanner(System.in);
		while(true){
			System.out.println("你跑了多少米？");
			j=in.nextInt();
			System.out.println("口渴吗？请输入(yesorno)");
			Stringthirst=in.next();
			if(j>400){
				if(!thirst.equals("yes")){
					System.out.println("好吧，那你继续跑吧！");
					continue;//不喝水，继续跑
				}else{
					System.out.println("过来喝水吧");
				}
				break;
			}
			else{
				continue;
			}
		}
	}
}

谢谢采纳

2. Java源码实现网络爬虫

//Java爬虫demo

importjava.io.File;
importjava.net.URL;
importjava.net.URLConnection;
importjava.nio.file.Files;
importjava.nio.file.Paths;
importjava.util.Scanner;
importjava.util.UUID;
importjava.util.regex.Matcher;
importjava.util.regex.Pattern;

publicclassDownMM{
publicstaticvoidmain(String[]args)throwsException{
//out为输出的路径,注意要以\结尾
Stringout="D:\JSP\pic\java\";
try{
Filef=newFile(out);
if(!f.exists()){
f.mkdirs();
}
}catch(Exceptione){
System.out.println("no");
}

Stringurl="http://www.mzitu.com/share/comment-page-";
Patternreg=Pattern.compile("<imgsrc="(.*?)"");
for(intj=0,i=1;i<=10;i++){
URLuu=newURL(url+i);
URLConnectionconn=uu.openConnection();
conn.setRequestProperty("User-Agent","Mozilla/5.0(WindowsNT6.3;WOW64;Trident/7.0;rv:11.0)likeGecko");
Scannersc=newScanner(conn.getInputStream());
Matcherm=reg.matcher(sc.useDelimiter("\A").next());
while(m.find()){
Files.(newURL(m.group(1)).openStream(),Paths.get(out+UUID.randomUUID()+".jpg"));
System.out.println("已下载:"+j++);
}
}
}
}

3. java求源代码

你是青鸟的吧这我写过有源码这里怎么上传压缩包啊

packageghhh;

importjava.util.Scanner;

publicclassDvD{

	publicstaticvoidmain(String[]args){
		
		intstate[]=newint[6];
		Stringname[]=newString[6];
		intdate[]=newint[6];
		intcount[]=newint[6];
		
		name[0]="权利的游戏";
		name[1]="命运之夜";
		name[2]="傲慢与偏见";		
		
		state[0]=1;
		state[1]=0;
		state[2]=1;
		
		date[0]=13;
		date[1]=0;
		date[2]=9;
		
		count[0]=23;
		count[1]=23;
		count[2]=23;
		intn;
		//	booleann=false;
		do{
		System.out.println("欢迎使用迷你DVD管理器");
		System.out.println("1.新增DVD");
		System.out.println("2.查看DVD");
		System.out.println("3.删除DVD");
		System.out.println("4.借出DVD");
		System.out.println("5.归还DVD");
		System.out.println("6.退出DVD");
		Scannerinput=newScanner(System.in);
		System.out.println("请选择：");
		n=input.nextInt();
		
		switch(n){
			case1:
				System.out.println("请输入要增加DVD的名称：");
				Stringname1=input.next();
				booleanflag=false;
				for(inti=0;i<name.length;i++){
					if(name[i]==null){
						name[i]=name1;
						flag=true;
						break;
				}
				}
				if(flag){
					System.out.println("新增DVD"+name1+"成功");
				}else{
					System.out.println("货架已满！增加失败！");
				}
				System.out.println("请输入0返回！");
				n=input.nextInt();
				break;
				
			case2:
				System.out.println("序号	"+"状态	"+"名称		"+"借出日期	"+"借出次数");
				
				for(inti=0;i<name.length;i++){
					if(name[i]!=null){
				Stringstate1=((state[i]==0)?"可借":"已借");
				Stringdate1=((date[i]==0)?"":date[i]+"日");
				Stringcount1=count[i]+"次";
				System.out.println((i+1)+"	"+state1+"	"+name[i]+"	"+date1+"		"+count1);
				}
				}
				
				System.out.println("请输入0返回！");
				n=input.nextInt();
				break;
				
			case3:
				System.out.println("请输入要删除的DVD名称：");
				Stringname2=input.next();
				intindex=-1;
				booleana=false;
				booleanflag1=false;
				for(inti=0;i<name.length;i++){
					if(name2.equals(name[i])&&state[i]==1){	
				System.out.println("此DVD已经借出，无法删除");
				a=true;
				break;
				}elseif(name2.equals(name[i])&&state[i]==0){
					a=true;
					index=i;
					flag1=true;
					System.out.println("删除成功！");
					break;
					}	
				}
				if(a==false){
					System.out.println("没有找到相同名称的DVD！");
				}
				if(flag1){
				for(inti=index;i<name.length;i++){
					if(i!=name.length-1){
					name[i]=name[i+1];
					state[i]=state[i+1];
					date[i]=date[i+1];
					count[i]=count[i+1];
				}
					name[name.length-1]=null;
					state[name.length-1]=0;
					date[name.length-1]=0;
					count[name.length-1]=0;
				}
				}
System.out.println("请输入0返回！");
				n=input.nextInt();
				break;
				
			case4:
				System.out.println("请输入要借出的DVD：");
				Stringname3=input.next();
				booleana3=false;
				booleanb3=false;
				for(inti=0;i<name.length;i++){
					if(name3.equals(name[i])&&state[i]==1){
						System.out.println("该DVD已经借出");
						a3=true;
					}elseif(name3.equals(name[i])&&state[i]==0){
						do{
						System.out.println("请输入借出的日期：");
intm=input.nextInt();
						
						if(m>31||m<1){
							System.out.println("请重新输入日期：");
							b3=true;
						}else{
							date[i]=m;
							state[i]=1;
							count[i]+=1;
						}
						
						}while(b3==true);
						System.out.println("借出成功！");
						a3=true;
					}
				}
				if(a3==false){
					System.out.println("没有该DVD");
				}
				System.out.println("请输入0返回！");
				n=input.nextInt();
				break;
				
			case5:
				System.out.println("请输入要归还的DVD：");
				Stringname5=input.next();
				booleanb5=false;
				booleanm5=false;
				for(inti=0;i<name.length;i++){
				if(name5.equals(name[i])&&state[i]==1){
					b5=true;
					do{
					System.out.println("请输入要归还DVD的日期：（归还日期请输入当月日期1~31）");
					inta5=input.nextInt();
				if(a5>31){
					System.out.println("请重新输入日期：");
					m5=true;
				
				}elseif(a5<date[i]){
					System.out.println("借出日期是"+date[i]+"日	输入的日期不能小于借出的日期,请重新输入日期：");
					m5=true;
				}else{
					state[i]=0;
					System.out.println("归还成功");
					System.out.println("借出日期是："+date[i]+"归还日期是："+a5+"日	租金一天一元：共"+(a5-date[i])+"元");
				date[i]=0;
				m5=false;
				}
				
					}while(m5==true);
					
					
				}elseif(name5.equals(name[i])&&state[i]==0){
					System.out.println("该DVD未借出，不可归还！");
				b5=true;
				}
				}
				
				if(b5==false){
					System.out.println("没有该名称的DVDV");
				}
				
				System.out.println("请输入0返回！");
				n=input.nextInt();
				break;
				
			case6:
				n=1;
				System.out.println("程序退出！");
				break;
				
			default:
				if(n==0){	
				}else{
				System.out.println("输入错误！请重新输入！");
				n=0;
				}
					break;
			
		}
		
		
		}while(n==0);
		
		System.out.println("谢谢使用！");
	}

}

看看有没有问题好久之前的了

4. java 源代码基础点的谢谢

package com.regex;
import java.io.*;
import java.net.URLDecoder;
import java.util.regex.*;
public class Regex {
private int REMARK=0;
private int LOGIC=0;
private int PHYSIC=0;
boolean start=false;

/**
* @param args
*/
public static void main(String[] args) { //测试方法
// TODO Auto-generated method stub
Regex re=new Regex();
re.regCount("Regex.java");
System.out.println("remark Line: "+re.REMARK);
System.out.println("logic Line: "+re.LOGIC);
System.out.println("physic Line: "+re.PHYSIC);

}/**
* @author BlueDance
* @param s
* @deprecated count
*/
public void regCount(String s){
String url=null;
try {
url=URLDecoder.decode(this.getClass().getResource(s).getPath(),"UTF-8");
} catch (Exception e) {
e.printStackTrace();
// TODO: handle exception
}
try {
BufferedReader br=new BufferedReader(new FileReader(new File(url)));
String s1=null;
while((s1=br.readLine())!=null){
PHYSIC++;
if(CheckChar(s1)==1){
REMARK++;
System.out.println("纯注释行："+s1);
}
if(CheckChar(s1)==2){
LOGIC++;
REMARK++;
System.out.println("非纯注释行："+s1);
}
if(CheckChar(s1)==3)
LOGIC++;
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}

}
/**
*
* @param s
* @return int
* @version check s
*/
public int CheckChar(String s){
String s1=null;
if(s!=null)
s1=s.trim();

//System.out.println(regCheck(s1,re));
if(regCheck(s1,"(//.*)")) //判断//开头的为纯注释行
return 1;
if(regCheck(s1,"(.*[;{})] *//.*)")) //判断不是//开头的非纯注释行
return 2;
if(regCheck(s1,"(//*.*)")){ //判断/*开头的纯注释行
start=true;
return 1;
}
if(regCheck(s1,"(.*[;{})]//*.*)")){ //判断不是/*开头的非纯注释行
start=true;
return 2;
}
if(regCheck(s1,"(.* */*/)")){ //判断*/结尾的纯注释行
start=false;
return 1;
}
if(regCheck(s1,"(.* */*/.*)")&&!strCheck(s1)){ //判断不是*/结尾的非纯注释行
if(strCheck(s1)){
start=false;
return 2;
}
}
if(start==true) //状态代码，start即/*开始时start=true*/结束时为false
return 1;
return 3;//ssssllll
}//aeee
/**
*
* @param s
* @param re
* @return boolean
*/
public boolean regCheck(String s,String re){ //正则表达试判断方法
return Pattern.matches(re,s);
}
public boolean strCheck(String s){ //中间有*/的字符判断此方法最关键
if(s.indexOf("*/")>0){
int count=0;
String y[]=s.split("/*/");
boolean boo[]=new boolean[y.length];
for (int i = 0; i < y.length-1; i++) {
char c[]=y[i].toCharArray();
for (int j = 0; j < c.length; j++) {
if(c[j]=='\\'&&c[j+1]=='"'){
count++;
}
}
if(count%2==0){
if(countNumber("\"",y[i])%2!=0){
boo[i]=true;
}else{
boo[i]=false;
}
}else{
if(countNumber("\"",y[i])%2==0){
boo[i]=true;
}else{
boo[i]=false;
}
}

}
for(int i=0;i<boo.length;i++){
if(!boo[i])
return false;
}
return true;
}
return false;
}
public int countNumber(String s,String y){ //此方法为我前面写的字符串出现次数统计方法,不懂的可以看我前面的文章
int count=0;
String [] k=y.split(s);
if(y.lastIndexOf(s)==(y.length()-s.length()))
count=k.length;
else
count=k.length-1;
if(count==0)
System.out.println ("字符串\""+s+"\"在字符串\""+y+"\"没有出现过");
else
return count;
return -1;
}

}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class GoodLucky extends JFrame implements ActionListener{

JTextField tf = new JTextField(); //实例化一个文本域
//设置两个按钮
JButton b1 = new JButton("开始");
JButton b2 = new JButton("停止");
boolean isGo = false;
//构造函数
public GoodLucky(){
b1.setActionCommand("start");//在开始按钮上设置一个动作监听 start
JPanel p = new JPanel(); //实例化一个可视化容器
//将两个按钮添加到可视化容器上面，用add方法
p.add(b1);
p.add(b2);
//在两个按钮上增加监听的属性,自动调用下面的监听处理方法actionPerformed(ActionEvent e)，如果要代码有更好的可读性，可用内部类实现动作
//监听处理。
b1.addActionListener(this);
b2.addActionListener(this);
//将停止按钮设置为不可编辑（即不可按的状态）
b2.setEnabled(false);

this.getContentPane().add(tf,"North"); //将上面的文本域放在面板的北方，也就是上面（上北下南左西右东）
this.getContentPane().add(p,"South"); //将可视化容器pannel放在南边，也就是下面
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置用户在此窗体上发起 "close" 时默认执行的操作，参数EXIT_ON_CLOSE是使用 System exit 方法退出应用程序。仅在应用程序中使用

this.setSize(300,200); //设置面板大小，宽和高
this.setLocation(300,300); //设置面板刚开始的出现的位置
Cursor cu = new Cursor(Cursor.HAND_CURSOR); //用指定名称创建一个新的定制光标对象，参数表示手状光标类型
this.setCursor(cu); //为指定的光标设置光标图像，即设置光标图像为上面所创建的手状光标类型
this.setVisible(true); //将面板可视化设置为true，即可视，如果为false，即程序运行时面板会隐藏
tf.setText("welcome you! "); //设置面板的标题为欢迎
this.go(); //调用go方法

}

public void go(){
while(true){ //这里是死循环，也就是说用户不点击停止按钮的话他一直循环出现随机数，直到用户点击停止按钮循环才能推出，具体流程在actionPerformed方法中控制。
if(isGo == true){ //上面所定义的isGo的初始值为false，所以程序第一次到此会跳过
String s = ""; //设置空字符串
for(int j = 1; j <= 7;j++){ //产生7个随机数
int i = (int)(Math.random() * 36) + 1;//每个随机数产生方式，这里定义灵活，可以自由定义随机数产生的方式
if(i < 10){
s = s + " 0" + i; //如果产生的随机数小于10的话做处理：这里就牵扯到一个重要的概念，简单叙述一下：
/*
当一个字符串与一个整型数项相加的意思是连接，上面的s = s + " 0" + i的意思是字符串s链接0再连接整型i值，而不会导致0和整型的i相加，
产生的效果为s0i,由于s为空字符串（上面定义过的），所以当i小于零时，在个位数前面加上0，比如产生的随机数i为7的话，显示效果为 07.
*/
}else{
s = s + " " + i; //如果产生的随机数比10打的话，那么加上空格显示，即数字和数字之间有个空格
}
//以上循环循环七次，以保证能出现7个随机数
}
tf.setText(s); //将产生的随机数全部显示在文本域上，用文本域对象tf调用它的设置文本的方法setText(String)实现。
}

//以下为线程延迟
try{
Thread.sleep(10); //线程类同步方法sleep，睡眠方法，括号里的单位为ms。
}catch(java.lang.InterruptedException e){
e.printStackTrace(); //异常捕获，不用多说。
}

}

}

//以下是上面设置的事件监听的具体处理办法，即监听时间处理方法，自动调用
public void actionPerformed(ActionEvent e){ //传入一个动作事件的参数e
String s = e.getActionCommand(); //设置字符串s来存储获得动作监听，上面的start
/*
以下这个条件语句块的作用为：用户点击开始后（捕获start，用方法getActionCommand()），将命令触发设置为true，从而执行上面的go方法中的循环体（因为循环体中要求isGo参数为true,而初始为false）。
执行循环快产生随机数，并将开始按钮不可编辑化，而用户只可以使用停止按钮去停止。如果用户按下停止时，也就是没有传入参数“start”的时候，
执行else语句块中的语句，isGo设置为false，将不执行上面go中的循环语句块，从而停止产生随机数，并显示，并且把开始按钮设置为可用，而把
停止按钮设置为不可用，等待用户按下开始再去开始新一轮循环产生随机数。
*/
if(s.equals("start")){ //如果捕获到start，也就是用户触发了动作监听器，那么下面处理
isGo = true; //设置isGo为true
b1.setEnabled(false); //将开始按钮设置为不可用
b2.setEnabled(true); //将停止按钮设置为可用
}else{
isGo = false; //将isGo设置为false，isGo为循环标志位
b2.setEnabled(false); //设置停止按钮为不可用（注意看是b2,b2是停止按钮）
b1.setEnabled(true); //设置开始按钮为可用
}

}

public static void main(String[] args){
new GoodLucky(); //产生类的实例，执行方法
}
}

5. java.util包的源码

在你安装的jdk中就有, 比如我的就在:
C:\Program Files\Java\jdk1.6.0_05\src.zip

6. java并发包源码怎么读

1. 各种同步控制工具的使用

1.1 ReentrantLock

ReentrantLock感觉上是synchronized的增强版，synchronized的特点是使用简单，一切交给JVM去处理，但是功能上是比较薄弱的。在JDK1.5之前，ReentrantLock的性能要好于synchronized，由于对JVM进行了优化，现在的JDK版本中，两者性能是不相上下的。如果是简单的实现，不要刻意去使用ReentrantLock。

相比于synchronized，ReentrantLock在功能上更加丰富，它具有可重入、可中断、可限时、公平锁等特点。

首先我们通过一个例子来说明ReentrantLock最初步的用法：

package test;

import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0;

@Override public void run() { for (int j = 0; j < 10000000; j++)
{ lock.lock(); try
{
i++;
} finally
{ lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}

}

有两个线程都对i进行++操作，为了保证线程安全，使用了ReentrantLock，从用法上可以看出，与synchronized相比，ReentrantLock就稍微复杂一点。因为必须在finally中进行解锁操作，如果不在finally解锁，有可能代码出现异常锁没被释放，而synchronized是由JVM来释放锁。

那么ReentrantLock到底有哪些优秀的特点呢？

1.1.1 可重入

单线程可以重复进入，但要重复退出

lock.lock();
lock.lock();try{
i++;

}
finally{
lock.unlock();
lock.unlock();
}

由于ReentrantLock是重入锁，所以可以反复得到相同的一把锁，它有一个与锁相关的获取计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就加1，然后锁需要被释放两次才能获得真正释放(重入锁)。这模仿了synchronized的语义；如果线程进入由线程已经拥有的监控器保护的 synchronized 块，就允许线程继续进行，当线程退出第二个（或者后续）synchronized块的时候，不释放锁，只有线程退出它进入的监控器保护的第一个synchronized块时，才释放锁。

public class Child extends Father implements Runnable{ final static Child child = new Child();//为了保证锁唯一
public static void main(String[] args) { for (int i = 0; i < 50; i++) { new Thread(child).start();
}
}
public synchronized void doSomething() {
System.out.println("1child.doSomething()");
doAnotherThing(); // 调用自己类中其他的synchronized方法
}
private synchronized void doAnotherThing() { super.doSomething(); // 调用父类的synchronized方法
System.out.println("3child.doAnotherThing()");
}
@Override
public void run() {
child.doSomething();
}
}class Father { public synchronized void doSomething() {
System.out.println("2father.doSomething()");
}
}

我们可以看到一个线程进入不同的synchronized方法，是不会释放之前得到的锁的。所以输出还是顺序输出。所以synchronized也是重入锁

输出：

1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
1child.doSomething()
2father.doSomething()
3child.doAnotherThing()
...

1.1.2.可中断

与synchronized不同的是，ReentrantLock对中断是有响应的。中断相关知识查看[高并发Java 二] 多线程基础

普通的lock.lock()是不能响应中断的，lock.lockInterruptibly()能够响应中断。

我们模拟出一个死锁现场，然后用中断来处理死锁

package test;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;import java.lang.management.ThreadMXBean;import java.util.concurrent.locks.ReentrantLock;public class Test implements Runnable{ public static ReentrantLock lock1 = new ReentrantLock(); public static ReentrantLock lock2 = new ReentrantLock(); int lock; public Test(int lock)
{ this.lock = lock;
} @Override
public void run()
{ try
{ if (lock == 1)
{
lock1.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock2.lockInterruptibly();
} else
{
lock2.lockInterruptibly(); try
{
Thread.sleep(500);
} catch (Exception e)
{ // TODO: handle exception
}
lock1.lockInterruptibly();
}
} catch (Exception e)
{ // TODO: handle exception
} finally
{ if (lock1.isHeldByCurrentThread())
{
lock1.unlock();
} if (lock2.isHeldByCurrentThread())
{
lock2.unlock();
}
System.out.println(Thread.currentThread().getId() + ":线程退出");
}
} public static void main(String[] args) throws InterruptedException {
Test t1 = new Test(1);
Test t2 = new Test(2);
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
Thread.sleep(1000); //DeadlockChecker.check();
} static class DeadlockChecker
{ private final static ThreadMXBean mbean = ManagementFactory
.getThreadMXBean(); final static Runnable deadlockChecker = new Runnable()
{ @Override
public void run()
{ // TODO Auto-generated method stub
while (true)
{ long[] deadlockedThreadIds = mbean.findDeadlockedThreads(); if (deadlockedThreadIds != null)
{
ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds); for (Thread t : Thread.getAllStackTraces().keySet())
{ for (int i = 0; i < threadInfos.length; i++)
{ if(t.getId() == threadInfos[i].getThreadId())
{
t.interrupt();
}
}
}
} try
{
Thread.sleep(5000);
} catch (Exception e)
{ // TODO: handle exception
}
}

}
};
public static void check()
{
Thread t = new Thread(deadlockChecker);
t.setDaemon(true);
t.start();
}
}

}

上述代码有可能会发生死锁，线程1得到lock1，线程2得到lock2，然后彼此又想获得对方的锁。

我们用jstack查看运行上述代码后的情况

下面举个例子：

package test;import java.util.concurrent.CyclicBarrier;public class Test implements Runnable{ private String soldier; private final CyclicBarrier cyclic; public Test(String soldier, CyclicBarrier cyclic)
{ this.soldier = soldier; this.cyclic = cyclic;
} @Override
public void run()
{ try
{ //等待所有士兵到齐
cyclic.await();
dowork(); //等待所有士兵完成工作
cyclic.await();
} catch (Exception e)
{ // TODO Auto-generated catch block
e.printStackTrace();
}

} private void dowork()
{ // TODO Auto-generated method stub
try
{
Thread.sleep(3000);
} catch (Exception e)
{ // TODO: handle exception
}
System.out.println(soldier + ": done");
} public static class BarrierRun implements Runnable
{ boolean flag; int n; public BarrierRun(boolean flag, int n)
{ super(); this.flag = flag; this.n = n;
} @Override
public void run()
{ if (flag)
{
System.out.println(n + "个任务完成");
} else
{
System.out.println(n + "个集合完成");
flag = true;
}

}

} public static void main(String[] args)
{ final int n = 10;
Thread[] threads = new Thread[n]; boolean flag = false;
CyclicBarrier barrier = new CyclicBarrier(n, new BarrierRun(flag, n));
System.out.println("集合"); for (int i = 0; i < n; i++)
{
System.out.println(i + "报道");
threads[i] = new Thread(new Test("士兵" + i, barrier));
threads[i].start();
}
}

}

打印结果：

集合

士兵5: done士兵7: done士兵8: done士兵3: done士兵4: done士兵1: done士兵6: done士兵2: done士兵0: done士兵9: done10个任务完成

1.7 LockSupport

提供线程阻塞原语

和suspend类似

LockSupport.park();
LockSupport.unpark(t1);

与suspend相比不容易引起线程冻结

LockSupport的思想呢，和Semaphore有点相似，内部有一个许可，park的时候拿掉这个许可，unpark的时候申请这个许可。所以如果unpark在park之前，是不会发生线程冻结的。

下面的代码是[高并发Java 二] 多线程基础中suspend示例代码，在使用suspend时会发生死锁。

而使用LockSupport则不会发生死锁。

另外

park()能够响应中断，但不抛出异常。中断响应的结果是，park()函数的返回，可以从Thread.interrupted()得到中断标志。

在JDK当中有大量地方使用到了park，当然LockSupport的实现也是使用unsafe.park()来实现的。

public static void park() { unsafe.park(false, 0L);
}

1.8 ReentrantLock 的实现

下面来介绍下ReentrantLock的实现，ReentrantLock的实现主要由3部分组成：

CAS状态
等待队列
park()

ReentrantLock的父类中会有一个state变量来表示同步的状态

* The synchronization state.

private volatile int state;

通过CAS操作来设置state来获取锁，如果设置成了1，则将锁的持有者给当前线程

final void lock() { if (compareAndSetState(0, 1))

setExclusiveOwnerThread(Thread.currentThread()); else

acquire(1);

}

如果拿锁不成功，则会做一个申请

public final void acquire(int arg) { if (!tryAcquire(arg) &&

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

selfInterrupt();

}

首先，再去申请下试试看tryAcquire，因为此时可能另一个线程已经释放了锁。

如果还是没有申请到锁，就addWaiter，意思是把自己加到等待队列中去

其间还会有多次尝试去申请锁，如果还是申请不到，就会被挂起

private final boolean parkAndCheckInterrupt() {

LockSupport.park(this); return Thread.interrupted();

}

同理，如果在unlock操作中，就是释放了锁，然后unpark，这里就不具体讲了。

2. 并发容器及典型源码分析

2.1ConcurrentHashMap

我们知道HashMap不是一个线程安全的容器，最简单的方式使HashMap变成线程安全就是使用Collections.synchronizedMap，它是对HashMap的一个包装

public static Map m=Collections.synchronizedMap(new HashMap());

同理对于List，Set也提供了相似方法。

但是这种方式只适合于并发量比较小的情况。

我们来看下synchronizedMap的实现

它会将HashMap包装在里面，然后将HashMap的每个操作都加上synchronized。

由于每个方法都是获取同一把锁(mutex)，这就意味着，put和remove等操作是互斥的，大大减少了并发量。

下面来看下ConcurrentHashMap是如何实现的

在ConcurrentHashMap内部有一个Segment段，它将大的HashMap切分成若干个段（小的HashMap），然后让数据在每一段上Hash，这样多个线程在不同段上的Hash操作一定是线程安全的，所以只需要同步同一个段上的线程就可以了，这样实现了锁的分离，大大增加了并发量。

在使用ConcurrentHashMap.size时会比较麻烦，因为它要统计每个段的数据和，在这个时候，要把每一个段都加上锁，然后再做数据统计。这个就是把锁分离后的小小弊端，但是size方法应该是不会被高频率调用的方法。

在实现上，不使用synchronized和lock.lock而是尽量使用trylock，同时在HashMap的实现上，也做了一点优化。这里就不提了。

2.2BlockingQueue

BlockingQueue不是一个高性能的容器。但是它是一个非常好的共享数据的容器。是典型的生产者和消费者的实现。

7. 求Java 日历的小程序的源代码

当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

Java内存分配中的堆

堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

8. java.util.* 这一类的包在哪里能查看其内容和作用。

java.io包是java处理输入输出的包，里面有各种用于读写数据的类。
java.util包是java的使用工具包，包括java提供给我们的各种使用工具类。
具体内容你可以看java官方API文档：https://docs.oracle.com/javase/8/docs/api/index.html，
进入后，你在左上角的Package那个框里选io或者util,下面那个框里就会列出这个包里所有接口、类和异常，你想具体看那个就点那个，右边那个框里面就会有详细的介绍。

9. java.util API 研究问题

1 你可能会发现有类库里的类 extends 了Object,这是不是多余呢？
这么做是为了长远的打算，现在是没什么用，将来有没有用，我也不知道

2.AbstractCollection 是支持泛型的，泛型不能用来定义数组，但可以使用反射API创建数组

3.这肯定是不一样的，如果一样就完了，他有专门的冲突解决办法，方法有很多种，例如线性探索、平方探索、二次哈希等，HashMap具体采用的那一种我没研究过

10. 什么是java源代码怎么查看

不知道你说的是浏览器的还是什么的，
如果是浏览器的那么简单找到工具-查看源代码，你就能看见代码了，
还有一个就是被编译成class文件的java用反编译工具可以看到源代码，
如果以上都不是你想要的答案，那么你所说的代码就是程序员写好的代码文件

阅读全文

热点内容

云隙服务器下载发布：2024-05-19 04:33:22 浏览：312

德国C语言发布：2024-05-19 04:13:40 浏览：959

音频管理器没有文件夹发布：2024-05-19 04:13:36 浏览：666

qq邮箱端口993服务器怎么填发布：2024-05-19 04:07:05 浏览：202

javaapi框架发布：2024-05-19 04:06:59 浏览：359

与存储结构无关的术语发布：2024-05-19 04:05:41 浏览：499

编译路由器固件选择发布：2024-05-19 03:56:28 浏览：39

手机f加密发布：2024-05-19 03:28:47 浏览：225

用什么密码写日记发布：2024-05-19 03:27:57 浏览：303

数据库access2003 发布：2024-05-19 02:49:39 浏览：620

javautil源码

与javautil源码相关的资讯