java包源碼

『壹』 java中的jar包是寫好的類那麼為什麼查看時需要導入源碼

在Eclipse查看開發包jar源碼的方法如下：

1. 選擇項目，右鍵中單擊【Properties】

2. 2.【Java Build Path】-【Configure Build Path】-【Libraries】，在下面找到如：Guava-r09.jar包，展開它，選擇【Source attachment】，單擊右邊的【Edit…】按鈕。

3. 3.在打開的窗口中，可選擇文件(jarzip)，目錄或工作空間中的jar文件，在這里我選擇External Folder…，選擇如E:/java project/guava即可。

4.連續單擊【OK】兩次回到Eclipse工作即可。

有源碼，把它加到eclipse中：

方法1：直接用壓縮打開相應的jar包，然後把源碼拖進去壓縮一下，最後選中工程刷新一下ok。

方法2：右擊referenced

libraries中需要導入源代碼的包，右擊properties->java source

attatchment，根據你源文件格式（源碼可以是直接src文件夾，也可以是壓縮成zip或jar後的壓縮文件）在右邊選擇合適的方式，最後點擊

ok。

至於如何源碼打進jar包，在eclipse中打jar包的時候有個「Export

java source files and

resources」選項，選中它打包就ok；也可以如方法1那樣，用eclipse生成一般jar包之後，用壓縮把src文件夾壓進去。

『貳』 如何在eclipse中看jar包源代碼

在Eclipse查看開發包jar源碼的方法如下：

1. 選擇項目，右鍵中單擊【Properties】
   

2.【Java Build Path】-【Configure Build Path】-【Libraries】，在下面找到如：Guava-r09.jar包，展開它，選擇【Source attachment】，單擊右邊的【Edit…】按鈕。

3.在打開的窗口中，可選擇文件(jarzip)，目錄或工作空間中的jar文件，在這里我選擇External Folder…，選擇如E:/java project/guava即可。

4.連續單擊【OK】兩次回到Eclipse工作平台即可。

『叄』 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不是一個高性能的容器。但是它是一個非常好的共享數據的容器。是典型的生產者和消費者的實現。

『肆』 如何把打包後的JAVA文件找出源碼

不能查看源碼的，現在基本都是打混淆包，不可能反編譯。

『伍』 java .jar包裡面存的是中間碼還是源碼

java包裡面只有class文件.應該算是中間碼

如果你是通過ide看到源碼的,或許你是通過maven下載自動關聯了源碼,或者是ide給你反編譯了

源碼我們指的是java文件,你看到的是class文件,屬於中間碼.

如果覺得有用的話,請關注下微信公帳號:早晚程序員,定期分享java技術,源碼,jvm,位元組碼,kafka,多線程,redis等.

『陸』 什麼是java源代碼 怎麼查看

不知道你說的是瀏覽器的還是什麼的，
如果是瀏覽器的那麼簡單找到工具-查看源代碼，你就能看見代碼了，
還有一個就是被編譯成class文件的java用反編譯工具可以看到源代碼，
如果以上都不是你想要的答案，那麼你所說的代碼就是程序員寫好的代碼文件

『柒』 Java源代碼

packagecom.;

importjava.util.ArrayList;
importjava.util.List;
importjava.util.Scanner;

importstaticjava.lang.System.out;
importstaticjava.lang.System.in;
/**
*Createdbytracyon2017/10/11.
*/
publicclassLR{

staticint[]numbers;
staticList<Domain>domains=newArrayList<>();

publicstaticvoidmain(String...asd){
intm,n;
out.print("請輸入數字個數N：");
n=input(1,Integer.MAX_VALUE);
out.print("請輸入計算行數M：");
m=input(1,10000);
out.println("請輸入"+n+"個數字,每個數字介於1跟1000000之間，用空格隔開:");
numbers=inputNumbers(n);
for(inti=0;i<m;i++){
domains.add(inputDomain(n,i+1));
}
for(Domaindomain:domains){
domain.output();
}
}

/**
*輸入一個介於min跟max之間的整數
*@parammin
*@parammax
*@return
*/
privatestaticintinput(intmin,intmax){
Scannerscanner=newScanner(in);
try{
inti=scanner.nextInt();
if(i<min||i>max){
out.print("輸入數字大小不符合要求，請重新輸入」");
returninput(min,max);
}
returni;
}catch(Exceptione){
out.print("您輸入的不是數字，請重新輸入「");
returninput(min,max);
}
}

/**
*輸入N個介於1到1000000之間的整數
*@paramn
*@return
*/
privatestaticint[]inputNumbers(intn){
Scannerscanner=newScanner(in);
StringnumStr=scanner.nextLine();
String[]nums=numStr.trim().split("\s+");
if(nums.length!=n){
out.println("輸入數字個數不對，請重新輸入：");
returninputNumbers(n);
}
int[]numbers=newint[n];
for(inti=0;i<n;i++){
try{
intnumber=Integer.valueOf(nums[i]);
if(number<1||number>10000){
out.print("輸入數字大小不符合要求，請重新輸入」");
numbers[i]=input(1,1000000);
}else{
numbers[i]=number;
}
}catch(NumberFormatExceptione){
out.print(String.format("您輸入的%s不是數字，請重新輸入：",nums[i]));
numbers[i]=input(1,1000000);
}
}
returnnumbers;
}

(intn,intindex){
out.println("請輸入第"+index+"行的2個數字L,R(1<=L<=R<=%d)用空格隔開：");
Scannerscanner=newScanner(in);
StringnumStr=scanner.nextLine();
String[]nums=numStr.trim().split("\s+");
if(nums.length!=2){
out.print(String.format("輸入數字個數不對，請重新輸入!",n));
returninputDomain(n,index);
}
Stringls=nums[0];
Stringrs=nums[1];
try{
intl=Integer.valueOf(ls);
intr=Integer.valueOf(rs);
if(l<1||r<l||r>n){
out.print(String.format("輸入數字大小不符合，請重新輸入!",n));
returninputDomain(n,index);
}
returnnewDomain(l,r,index);
}catch(NumberFormatExceptione){
out.println(String.format("輸入數字格式錯誤，請重新輸入2個數字L,R(1<=L<=R<=%d)用空格隔開：",n));
returninputDomain(n,index);
}
}

privatestaticclassDomain{
intl;
intr;
intindex;

Domain(intl,intr,intindex){
this.l=l;
this.r=r;
this.index=index;
}

voidoutput(){
intresult=0;
for(inti=l-1;i<r;i++){
result+=numbers[i];
}
out.println(String.format("第%d行：第%d到第%d個數之和為：%d",index,l,r,result));
}
}
}

『捌』 java核心源碼包存放在什麼目錄下

在你安裝的jdk的安裝目錄中 有個src.zip 裡面都是java的核心源碼。

『玖』 JAVA源代碼的擴展名為（ ）

JAVA源代碼的擴展名為.java。

Java源程序（.java文件）-java位元組碼文件（.class文件）-由解釋執行器（java.exe）將位元組碼文件載入到java虛擬機（jvm）-位元組碼文件（.class）就會在java虛擬機中執行。

Java的基本包

java.lang其中包含有：介面：Comparable、Cloneable、Runable等；類：八個基本數據類型封裝類、Byte、Short、Integer、Long、Boolean、Character、Float、Double等。

(9)java包源碼擴展閱讀

Java為一個面向對象的語言。對程序員來說，這意味著要注意應中的數據和操縱數據的方法（method），而不是嚴格地用過程來思考。數據和方法一起描述對象（object）的狀態和行為。每一對象是其狀態和行為的封裝。

類按一定體系和層次安排的，使得子類可以從超類繼承行為。在這個類層次體系中有一個根類，它是具有一般行為的類。Java程序是用類來組織的。

Java還包括一個類的擴展集合，分別組成各種程序包（Package），用戶可以在自己的程序中使用。

例如，Java提供產生圖形用戶介面部件的類（java.awt包），這里awt為抽象窗口工具集（abstract windowing toolkit）的縮寫，處理輸入輸出的類（java.io包）和支持網路功能的類（java.net包）。

『拾』 怎麼查看jar包裡面的源碼

在Eclipse查看開發包jar源碼的方法如下：
1.選擇項目，右鍵中單擊【Properties】
2.【Java Build Path】-【Configure Build Path】-【Libraries】，在下面找到如：Guava-r09.jar包，展開它，選擇【Source attachment】，單擊右邊的【Edit…】按鈕。
3.在打開的窗口中，可選擇文件(jar\zip)，目錄或工作空間中的jar文件，在這里我選擇External Folder…，選擇如E:/java project/guava即可。

4.連續單擊【OK】兩次回到Eclipse工作平台即可。
或者：
有源碼，把它加到eclipse中：
方法1：直接用壓縮軟體打開相應的jar包，然後把源碼拖進去壓縮一下，最後選中工程刷新一下ok。
方法2：右擊referenced libraries中需要導入源代碼的包，右擊properties->Java source attatchment，根據你源文件格式（源碼可以是直接src文件夾，也可以是壓縮成zip或jar後的壓縮文件）在右邊選擇合適的方式，最後點擊ok。
至於如何源碼打進jar包，在eclipse中打jar包的時候有個「Export java source files and resources」選項，選中它打包就ok；也可以如方法1那樣，用eclipse生成一般jar包之後，用壓縮軟體把src文件夾壓進去。