Java開發(fā)的應該
如何掌握上述相關技術？
Java開發(fā)的應該如何掌握上述相關技術？
一：首先，有這樣的一種情況很常見，對于想自學Java開發(fā)的人來說，他們
大多數(shù)都是非常盲目的，不知道自己改如何入手，很多人在網(wǎng)上找一些視頻，然后瘋狂的過視頻，很快就把一塊內容都學完，他們理解的學完了就是視
頻看完了，但是讓他們動手去做東西卻做不出來，而我的理解學完了就是自己能寫出東西，所以對于初學者來說一定不能盲目，要有自己的規(guī)劃，不然
就是浪費時間白忙活。
二：既然是學習Java開發(fā)專業(yè)技術，我個人的建議是，一定要有一個能指導
你的人，不能都靠自己閉門造車，這樣的行為并不聰明，結識一位這方面的人才，時不時去問問人家問題，不然你可能會發(fā)現(xiàn)一個小問題能困擾你一天
，**后還不知道是什么原因。
三：學習Java開發(fā)技術，不能跟學數(shù)學語文一樣對待，比較剛接觸代碼是不
容易記住的，所以要掌握上述的技術，你還要知道學習Java開發(fā)技術有哪些“坑”。對于學習方法這塊是尤為重要的，怎么學才能讓你學完了能記住之
前學的那些，不至于學完了就忘，這個問題值得你學習之前去思考的。
四：根據(jù)我多年的學習情況來看，你平時一定要養(yǎng)成好的學習習慣，就說我
自己吧！我就喜歡把自己曾經(jīng)遇到的問題整理在電腦的日記本上，然后我會搜集一下博客相關的Java技術文章，一些我認為比較有用的網(wǎng)站，以后都能
用的上，這是我個人的學習習慣，相信我，如果你想走的更遠，一定要養(yǎng)成習慣。
**后給大家一些詳細的學習安排路線：
Java基礎：Java基礎語法、數(shù)組、類與對象、繼承與多態(tài)、異常、范型、集
合、流與文件、反射、枚舉、自動裝箱和注解。
數(shù)據(jù)庫：mysql、oracle
Javaweb：HTML與CSS網(wǎng)頁開發(fā)基礎、Java腳本語言、搭建開發(fā)環(huán)境、JSP基
本語法、JSP內置對象、JavaBean技術、Servlet技術、Ajax技術
框架：Struts2、Hibernate、Spring、SpringMVC、mybatis
大數(shù)據(jù)核心知識
Hadoop基礎
Hadoop1介紹
hadoop1架構
hadoop2架構（對比hadoop1）
hadoop2環(huán)境搭建
HDFS操作
yarn操作
Hadoop應用
Hive數(shù)據(jù)倉庫
zookeeper系統(tǒng)服務
HBase非關系型數(shù)據(jù)庫
Sqoop數(shù)據(jù)庫抽取工具
Flume日志抽取工具
Spark基礎
環(huán)境搭建
Spark平臺介紹
RDD彈性分布式數(shù)據(jù)集
Scala編程
Spark應用
Spark-SQL組件
DataFrame組件
課程優(yōu)勢
1.真實的企業(yè)項目；
2.目前企業(yè)中應用廣泛的技術路線；
3.部分Spark源碼剖析，從源碼層面提升問題解決能力。
4.從hadoop1到hadoop2機制原理詳細解說；
5.生產環(huán)境hadoop集群調優(yōu)經(jīng)驗；
6.企業(yè)真實項目實戰(zhàn)；
本階段學習目標
1.了解hadoop機制原理 ；
2.了解hadoop集群搭建過程；
3.了解Hdfs API使用以及mr編程模型；
4.了解hive、hbase、sqoop、flume等組件的使用方法；
5.Spark平臺的優(yōu)勢以及Spark集群的搭建過程；
6.Scala程序設計基礎；
7.Spark-SQL和DataFrame API詳解。
本階段學習效果
1.了解hadoop集群的搭建過程；
2.能夠**mr和hive來實現(xiàn)簡單的數(shù)據(jù)清洗的業(yè)務需求；
3.能夠了解數(shù)據(jù)的抽取，轉換，清洗，建模，入庫過程；
4.掌握Spark集群的搭建；
5.掌握函數(shù)式編程思想，能夠根據(jù)業(yè)務需求編寫高質量的Scala程序；
6.掌握大規(guī)模離線數(shù)據(jù)的計算、分析能力。
java并發(fā)編程入門：synchronized 與 Lock 的那點事
>
此篇
synchronized和Lock應用舉例轉自：http://www.cnblogs.com/benshan/p/3551987.html
**近在做一個監(jiān)控系統(tǒng)，該系統(tǒng)主要包括對數(shù)據(jù)實時分析和存儲兩個部分，由于并發(fā)量比較高，所以不可避免的使用到了一些并發(fā)的知識。為了實現(xiàn)這些要求，后臺使用一個隊列作為緩存，對于請求只管往緩存里寫數(shù)據(jù)。同時啟動一個線程監(jiān)聽該隊列，檢測到數(shù)據(jù)，立即請求調度線程，對數(shù)據(jù)進行處理。 具體的使用方案就是使用同步保證數(shù)據(jù)的正常，使用線程池提高效率。
同步的實現(xiàn)當然是采用鎖了，java中使用鎖的兩個基本工具是 synchronized 和 Lock。
一直很喜歡synchronized，因為使用它很方便。比如，需要對一個方法進行同步，那么只需在方法的簽名添加一個synchronized關鍵字。
// 未同步的方法
public void test() {}
// 同步的方法
pubilc synchronized void test() {}
synchronized 也可以用在一個代碼塊上，看
public void test() {
synchronized(obj) {
System.out.PRintln(“===”);
}
}
synchronized 用在方法和代碼塊上有什么區(qū)別呢？
synchronized 用在方法簽名上（以test為例），當某個線程調用此方法時，會獲取該實例的對象鎖，方法未結束之前，其他線程只能去等待。當這個方法執(zhí)行完時，才會釋放對象鎖。其他線程才有機會去搶占這把鎖，去執(zhí)行方法test,但是發(fā)生這一切的基礎應當是所有線程使用的同一個對象實例，才能實現(xiàn)互斥的現(xiàn)象。否則synchronized關鍵字將失去意義。
（但是如果該方法為類方法，即其修飾符為static，那么synchronized 意味著某個調用此方法的線程當前會擁有該類的鎖，只要該線程持續(xù)在當前方法內運行，其他線程依然無法獲得方法的使用權！）
synchronized 用在代碼塊的使用方式：synchronized(obj){//todo code here}
當線程運行到該代碼塊內，就會擁有obj對象的對象鎖，如果多個線程共享同一個Object對象，那么此時就會形成互斥！特別的，當obj == this時，表示當前調用該方法的實例對象。即
public void test() {
…
synchronized(this) {
// todo your code
}
…
}
此時，其效果等同于
public synchronized void test() {
// todo your code
}
使用synchronized代碼塊，可以只對需要同步的代碼進行同步，這樣可以大大的提高效率。
小結：
使用synchronized 代碼塊相比方法有兩點優(yōu)勢：
1、可以只對需要同步的使用
2、與wait()/notify()/nitifyAll()一起使用時，比較方便
wait() 與notify()/notifyAll()
這三個方法都是Object的方法，并不是線程的方法！
wait():釋放占有的對象鎖，線程進入等待池，釋放cpu,而其他正在等待的線程即可搶占此鎖，獲得鎖的線程即可運行程序。而sleep()不同的是，線程調用此方法后，會休眠一段時間，休眠期間，會暫時釋放cpu，但并不釋放對象鎖。也就是說，在休眠期間，其他線程依然無法進入此代碼內部。休眠結束，線程重新獲得cpu,執(zhí)行代碼。wait()和sleep()**大的不同在于wait()會釋放對象鎖，而sleep()不會！
notify(): 該方法會喚醒因為調用對象的wait()而等待的線程，其實就是對對象鎖的喚醒，從而使得wait()的線程可以有機會獲取對象鎖。調用notify()后，并不會立即釋放鎖，而是繼續(xù)執(zhí)行當前代碼，直到synchronized中的代碼全部執(zhí)行完畢，才會釋放對象鎖。JVM則會在等待的線程中調度一個線程去獲得對象鎖，執(zhí)行代碼。需要注意的是，wait()和notify()必須在synchronized代碼塊中調用。
notifyAll()則是喚醒所有等待的線程。
為了說明這一點，舉例如下：
兩個線程依次打印”A”“B”,總共打印10次。
public class Consumer implements Runnable {
@Override
public synchronized void run() {
// TODO Auto-generated method stub
int count = 10;
while(count > 0) {
synchronized (Test. obj) {
System. out.print( "B");
count --;
Test. obj.notify(); // 主動釋放對象鎖
try {
Test. obj.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Produce implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
int count = 10;
while(count > 0) {
synchronized (Test. obj) {
//System.out.print("count = " count);
System. out.print( "A");
count --;
Test. obj.notify();
try {
Test. obj.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
測試類如下：
public class Test {
public static final Object obj = new Object();
public static void main(String[] args) {
new Thread( new Produce()).start();
new Thread( new Consumer()).start();
}
}
這里使用static obj作為鎖的對象，當線程Produce啟動時（假如Produce首先獲得鎖，則Consumer會等待），打印“A”后，會先主動釋放鎖，然后阻塞自己。Consumer獲得對象鎖，打印“B”，然后釋放鎖，阻塞自己，那么Produce又會獲得鎖，然后…一直循環(huán)下去，直到count = 0.這樣，使用Synchronized和wait()以及notify()就可以達到線程同步的目的。
除了wait()和notify()協(xié)作完成線程同步之外，使用Lock也可以完成同樣的目的。
ReentrantLock 與synchronized有相同的并發(fā)性和內存語義，還包含了中斷鎖等候和定時鎖等候，意味著線程A如果先獲得了對象obj的鎖，那么線程B可以在等待指定時間內依然無法獲取鎖，那么就會自動放棄該鎖。
但是由于synchronized是在JVM層面實現(xiàn)的，因此系統(tǒng)可以監(jiān)控鎖的釋放與否，而ReentrantLock使用代碼實現(xiàn)的，系統(tǒng)無法自動釋放鎖，需要在代碼中finally子句中顯式釋放鎖lock.unlock();
同樣的例子，使用lock 如何實現(xiàn)呢？
public class Consumer implements Runnable {
private Lock lock;
public Consumer(Lock lock) {
this. lock = lock;
}
@Override
public void run() {
// TODO Auto-generated method stub
int count = 10;
while( count > 0 ) {
try {
lock.lock();
count --;
System. out.print( "B");
} finally {
lock.unlock(); //主動釋放鎖
try {
Thread. sleep(91L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
public class Producer implements Runnable{
private Lock lock;
public Producer(Lock lock) {
this. lock = lock;
}
@Override
public void run() {
// TODO Auto-generated method stub
int count = 10;
while (count > 0) {
try {
lock.lock();
count --;
System. out.print( "A");
} finally {
lock.unlock();
try {
Thread. sleep(90L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
調用代碼：
public class Test {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Consumer consumer = new Consumer(lock);
Producer producer = new Producer(lock);
new Thread(consumer).start();
new Thread( producer).start();
}
}
使用建議：
在并發(fā)量比較小的情況下，使用synchronized是個不錯的選擇，但是在并發(fā)量比較高的情況下，其性能下降很嚴重，此時ReentrantLock是個不錯的方案。
——————————-<全文完>——————————————————————————————————-
相關推薦：
蘇州JAVA培訓 蘇州JAVA培訓班 蘇州JAVA培訓機構
個試聽名額
