17 Aralık 2013 Salı

Paralel İşlemler, PLINQ ve Task Parallel Library

Not : Yazı çok uzun ve bir çok konuya değiniyor. Zaman içinde bu yazıları daha küçük yazılara bölmeyi planlıyorum.

.Net Task Parallel Library

Konuyu Task Parallel Library başlıklı yazıya taşıdım.

.Net ThreadPool

.Net 4.0 ile gelen ThreadPool sınıfı yaratılabilecek azami thread sayısını dinamik olarak hesaplıyor.

MSDN'nin dediğine göre :

There is one thread pool per process. Beginning with the .NET Framework version 4, the default size of the thread pool for a process depends on several factors, such as the size of the virtual address space. A process can call the GetMaxThreads method to determine the number of threads. The number of threads in the thread pool can be changed by using the SetMaxThreads method. Each thread uses the default stack size and runs at the default priority. 
ThreadPool.SetMaxThreads için örnek : İlk parametre worker thread sayısını, ikinci parametre ise I/O completion thread sayısını belirtiyor.

4 tane Core i5 CPU'ya sahip 3 GB hafıza taşıyan sistemim için bu rakamlar :

1023  tane worker thread ve 1000 tane de I/O completion thread çıkınca bayağı şaşırdım. Bu kadar çok thread açılabileceğini hiç sanmazdım.

I/O Completion Thread Nedir ?
.Net ile gelen bazı sınıflar (Stream sınıfları, SqlConnection, WebClient gibi)  BeginXXX, EndXX metodları sunuyorlar. Bu metodları çağırınca I/O Completion threadleri tarafından işletiliyorlar.Aşağıdaki şekilde Completion Port tarafından yönetiliyormuş gibi gösterilen threadleri görebiliriz.  Ama yukarıdaki açıklamadan da anlaşıldığı gibi aslında threadler Completion Port tarafından değil, ThreadPool tarafından yönetiliyor.
Unutmadan eklemek lazım I/O Completion Ports made easy örneğinde de görüldüğü gibi GetQueuedCompletionStatus metodunu çağıran thread'leri biz yaratıyoruz. Bu yüzden bizim yarattıklarımız ThreadPool tarafından yönetilenlere dahil değil.

Limit number of processors used in ThreadPool sorusunda da cevaplandığı gibi sistemdeki işlemci sayısından daha düşük bir sayı verilmesi engellenmiş. Ancak aşağıdaki örnekte olduğu gibi kullanılması istenilen işlemci sayısını düşürerek mevcut işlemcilerin tamamını değil de daha azının kullanılmasını istemek mümkün olabiliyor.

Peki ThreadPool sınıfını kimler kullanıyor ? Are ThreadPool settings global or only for work items? sorusundaki cevaba göre 

  •     ThreadPool
  •     System.Threading.Timer
  •     System.Timers.Timer
  •     TPL Tasks
işleri için ThreadPool sınıfının threadleri kullanılıyor. System.Windows.Threading.DispatcherTimer ve System.Windows.Forms.Timer sınıfları ise GUI thread'i üzerinde çalıştıkları için etkilenmiyorlar.

QueueUserWorkItem
QueueUserWorkItem metodu aynı Java'daki execute metodu gibi bir işi teslim ediyor ve geriye dönüş yapılmıyor.
Aslında bu metodu kullanma artık demode oldu. Onun yerine yeni TPL ile gelen Task.Factory.StartNew(()=>waitCB);
metodunu kullanmak lazım.
QueueUserWorkItem metodundan UI thread'e mesaj yollamak

Konuyu buraya taşıdım.
 .Net Winforms
BackGroundWorker

Konuyu buraya taşıdım.  

QT

QtConcurrent.run
QtConcurrent sınıfı Parallel.Invoke sınıfına benzer şekilde bazı metodları paralel çalıştırma imkanı verir. Dokümantasyonunda da açıklandığı gibi bu metod aslında global QThreadPool nesnesine yeni bir iş atar. Sebebini anlamadığım bir şekilde dokümantasyonda atanan işi iptal etmenin imkanı yoktur ancak QFuture nesnesi ile işin sonucu alınabilir deniyor.

Java'daki CompletionService  veya .Net'teki ContinueWith yapısına benzer şekilde verilen iş bitince bir kod çalıştırmak için buradaki soruda da açıklandığı gibi QFutureWatcher sınıfı kullanılabilir.


Java
Java ile gelen Paralel sınıflar aşağıdaki gibi.
Bu sınıflar arasında en karmaşık yapıya sahip olan ThreadPoolExecutor sınıfının detaylarını gösteren bir şekil ise aşağıda.

Eğer ThreadPool ExecutorService kullanılmadan yaratılmak istenirse aşağıdaki gibi bir kod parçası kullanılabilir.

PriorityBlockingQueue<Runnable> workQueue = new PriorityBlockingQueue<Runnable>(20, yourPriorityComparator);
ExecutorService executorService = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, workQueue);

Bir ThreadPoolExecutor içindeki thread sayısı corePoolSize ve maxPoolSize parametreleri tarafından belirlenir. Bu sayılar kaç tane thread'in sürekli hayatta kalacağını ve eğer gerekirse kaç tane daha yeni thread yaratılabileceğini belirtir. Aşağıdaki şekilde bunu görebiliriz.

getActiveCount
Kaç tane threadin çalıştığını gösterir. Burada anlatıldığı gibi metodun döndürdüğü sayı sayı yaklaşık bir değerdir. Buradaki örnekte, her thread işe başlarken ve bitirirken çağırılan beforeExecute ve afterExecute metodları kullanılarak daha kesin bir sonuç elde etme yöntemi gösterilmiş.Kod parçası aşağıda.

private AtomicInteger activeCount = new AtomicInteger();

@Override
public int getActiveCount() {
    return activeCount.get();
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
    activeCount.incrementAndGet();
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
    activeCount.decrementAndGet();
}

ExecutorService ile yaratılabilen thread pool tipleri

newSingleThreadExecutor (tek thread ile çalışır, sınırsız sayıda iş eklenebilir)
newSingleThreadExecutor tek bir thread yaratır. Eğer thread sayısından fazla iş gelirse yeni işler bir kuyrukta bekletilir.

Thread pool ile istenirse ThreadFactory de kullanılabilir. Regarding daemon thread providing some service to non daemon thread sorusunda tüm thread'leri daemon olarak yaratan bir factory örneği var. Aşağıdaki örnekte thread'e isim de veriliyor. Thread daemon olunca GUI thread'i sonlanırken diğer thread'lerin bitmesini beklemek zorunda kalmıyor.
Passing a ThreadFactory to the ScheduledThreadPoolExecutor sorusunda ise threadlere sadece isim veren bir başka örnek var.
Assign Priority for Callable type threads sorusunda ise threadlere öncelik atayan örnek var.


newFixedThreadPool (thread sayısı sabittir, sınırsız sayıda iş eklenebilir)
newFixedThreadPool  tipinde verilen sayı kadar sabit thread yaratılır ve threadler boş kalsalar bile yok edilmezler. Sayı her zaman sabittir. Eğer thread sayısından fazla iş gelirse yeni işler bir kuyrukta bekletilir.
Kuyruk sınırsız olduğu için de sınırsız sayıda iş eklenebilir.

Eper sabit sayıda thread ve sınırlı sayıda iş eklenmesini istiyorsak aşağıdaki kodu kullanabiliriz. Kuyruk dolunca default AbortPolicy çağırılır. Bu policy de verilen iş kabul edemeyeceğini belirten RejectedExecutionException atar.
new ThreadPoolExecutor(threadPoolSize,
                        threadPoolSize,
                        0L,
                        MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>(1000));
  
Aşağıdaki Executors.newFixedThreadPool metodunun içini gösteren kod parçası sabit sayıda thread yaratıldığını gösteriyor.

Aşağıdaki örnekte sistemdeki çekirdek sayısı kadar sabit thread yaratma kodu var.

Runtime.getRuntime().availableProcessors() ile alınan çekirdek sayısı sadece bir örnek. Eğer I/O için bloke olma yüzdesi fazlaysa daha fazla sayıda thread bile yaratılabilir.

Specify task order execution in Java sorusunda bu thread pool çeşidine verilen işlere öncelik atanması çözümü ilginç. Örnek çözüm aşağıda.


newCachedThreadPool (thread sayısı dinamik olarak ayarlanır)
newCachedThreadPool tipinde threadler belli bir süreden fazla (60 saniye) boş kaldıkları zaman kaynak kullanımını azaltmak için öldürülürler.Eğer aktif thread sayısından fazla iş gelirse yeni iş için yeni bir thread yaratılır.
 Yalnız dikkat edilmesi gereken bir nokta var .
If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.
cümlesinden de anlaşıldığı gibi eğer azami thread sayısı verilmişse ve tüm threadler meşgul ise yeni reddedilir. 
Ancak newCachedThreadPool  kullanımında azami thread sayısı Integer.MAX_VALUE olarak kullanıldığı için yaratılabilecek thread sayısına bir üst sınır konulmamış oluyor. Dolayısıyla sistem yeni bir thread açabildiği müddetçe tüm threadler meşgul olsa bile yeni iş reddedilmez.

Impossible to make a cached thread pool with a size limit? sorusunda ThreadPoolExecutor sınıfının ne zaman yeni thread yaratacağı açıklanmış.

  1. If the thread pool has not reached the core size, it creates new threads.
  2. If the core size has been reached and there is no idle threads, it queues tasks.
  3. If the core size has been reached, there is no idle threads, and the queue becomes full, it creates new threads (until it reaches the max size). 
  4. If the max size has been reached, there is no idle threads, and the queue becomes full, the rejection policy kicks in.
Aşağıdaki şekilde de algoritma görülebilir.

newCachedThreadPool ile yaratılan sınıfın core thread sayısından fazla iş gelince yeni thread yaratılmasının sebebi  SynchronousQueue kullanması. Bu sınıfın boyu her zaman 0. Dolayısıyla yeni iş gelince madde 3'e göre kuyruk hep dolu olacağı için yeni bir thread yaratılacak.

60 saniye keep alive süresi olarak adlandırılıyor ve açıklamada da görüldüğü gibi setKeepAliveTime metodu ile süre değiştirilebiliyor. 


newCachedThreadPool core pool size olarak 0 ile başlatılıyor. Bu yüzden hiç iş gelmezse 0 tane thread ile de kalabilir. Eğer 0'dan farklı bir sayı ile başlatılsaydı ve hiç iş gelmezse core thread'lerin bile yok edilmesi istenseydi allowCoreThreadTimeOut metodu ile bu işlem gerçekleştirilebilirdi.

newSingleThreadScheduledExecutor
newSingleThreadScheduledExecutor tipinde periyodik olarak çalışması gereken işleri çalıştırılan bir yapı yaratılır. ScheduledExecutorService ve Timer arasındaki farkı görmek için bu soruya bakılabilir.

Tek Seferlik (SingleShot) İşler 
İşi gecikmeli olarak tek bir sefer çalıştırmak istiyorsak aşağıdaki gibi yapılabilir.

Periyodik İşler
İşi periyodik olarak çalıştırmak için aşağıdaki gibi yapılabilir.

Bir başka örnekte ise her 5 saniyede çalışan kod içinse aşağıdaki gibi yapmak lazım.
Executors.newSingleThreadScheduledExecutor()
    .scheduleAtFixedRate(new MyRunnable(),
                        0, //initial delay
                        5, //delay
                        TimeUnit.SECONDS);
Bu çalışma şeklinde aynı anda iki timer expire ederse tek thread olduğu için sadece biri çalıştırılabiliyor. Diğeri sırasını beklemek zorunda.
 
newScheduledThreadPool
ScheduledExecutorService yazısına taşıdım.

Executor.execute 
Bu metod Runnable arayüzü ile kullanılırsa QT'dekinden bile daha ilkel görünüyor. Çünkü ne bir şekilde işi iptal etme ne de Future nesnesi ile sonucu alabilme imkanı var. Sebebi ise  metodun imzasının şöyle olmasıvoid execute (Runnable command) ;

ExecutorService es = Executors.newCachedThreadPool(50);
es.execute(new Job());

public class Job implements Runnable {
    public void run() {
    }
}
Why cannot run() of Runnable throw checked Exceptions? sorusunda da açıklandığı gibi Runnable aslında en eski arayüzlerden birisi ve daha çok bir kodlama yöntemiyle bir thread yaratıp onun içinde çalıştırmak üzere tasarlanmış. 

Daha sonra ortaya çıkan Callable arayüzü aşağıda da görülebileceği gibi Future nesnesi aracılığıyla bir sonuç dönme imkanı da sunuyor.

Eğer bu metod FutureTask ile kullanılırsa kullanması daha kolay bir yapı ortaya çıkıyor. Örnek için Paralel Örüntüler başlıklı yazıya bakabilirsiniz.

ExecutorService.submit
Bu metod ile Future nesnesi alabilme imkanı var. CompletionService ile beraber kullanılınca, kullanımı çok zevkli bir yapı ortaya çıkıyor.
    ExecutorService es = Executors.newCachedThreadPool();

    Future<Boolean> f = es.submit(new Job());

    public class Job implements Callable{

        public boolean call() {

        }

    }

Burada dikkat edilmesi gereken nokta eğer worker thread exception atarsa Future.get()  metodu çağırılınca ExecutionException alabilir. Bu yüzden thread'in sonucunu alırken aşağıdakine benzer bir kod işe yarayabilir.


ExecutorCompletionService
CompletionService .Net'teki ContinueWith yapısına benzese de bence aynı kolaylığı kesinlikle sağlamıyor.

CompletionService örneği aşağıda. Bu yapıyla tüm task'ların sonucunu almak çok kolay.
Under-appreciated Java Classes Part I: CompletionService yazısında da bu sınıfı kullanmak için örnekler var.

Bu sınıfı kullanırken dikkat edilmesi gereken nokta ecs.take().get() metodunu çağırırken dikkatli olmak yoksa bloke olabiliriz. Bu durumdan kaçınmak için yapılması gereken ya verilen iş sayısını sayarak henüz bitmemiş olduğundan eminsek çağırmak ya da poll metodunu kullanmak.


ExecutorService.execute ile başlatılan işi iptal etme
İptidai bir yöntem olarak aşağıdakine benzer bir kod kullanılabilir.

ExecutorService es = Executors.newFixedThreadPool(5);
Worker worker = new Worker();                  
es.execute(worker);
//Arada bir zaman geçsin
worker.interrupt();
//veya
es.shutdownNow();
Worker thread ise iptal edilme işlemini aşağıdakine benzer bir kod parçası ile anlayabilir.

while(!Thread.currentThread().isInterrupted()){
    try{
        // birşeyler yap
    }
    catch(InterruptedException e){
        Thread.currentThread().interrupt();
    }
}
ExecutorService.submit ile başlatılan işi iptal etme
Time limit on individual threads with ExecutorService sorusunda ise başlanılan işi belli bir süre sonra iptal etme örneği verilmiş.
ExecutorService.submit ile başlatılan işi duraklatma
Java ExecutorService pause/resume a specific thread sorusunda submit edilen bir işi duraklatma ve devam ettirme örneği var.
 

ExecutorService.invokeAll
invokeAll metodu ile çağıran thread tüm işler bitinceye kadar bekler. 


invokeAll metodunun bekleme döngüsünü gösteren kod parçası aşağıda.

ForkJoinPool.invoke
Konuyu Fork-Join Framework başlıklı yazıya taşıdım.

ExecutorService ile .Net'teki ContinueWith benzeri bir yapı
submit metodu ile döndürülen Future nesnesi biten işin sonucunu verir ancak submit işlemini yapan thread'in Future nesnesi üzerinden beklemesi gerekir. Eğer beklemek istemiorsak Java executors: how to be notified, without blocking, when a task completes? sorundaki gibi bir sınıf kullanmamız gerekir.



ExecutorService kapatma yöntemleri

shutDown
shutDown metodu ile tüm işlerin bitirilmesi ve yeni işlerin kabul edilmemesi ExecutorService sıfınına bildirilir.

shutDownNow
shutDownNow tüm threadleri derhal durdurmaya çalıır. Bu metod Thread.interrupt() metodunu kullanır. Eğer bizim threadimiz bu metod çağırılınca gönderilen InterruptedException'ı bir şekilde yutuyorsa problem çıkabilir.

awaitTermination
awaitTermination metodu shutDown metodu çağırıldıktan sonra, verilen süre kadar veya tüm işler bitirilinceye kadar bekleyebilmeyi sağlar. Örnek :

service.shutDown();//Yeni gelen işleri reddet
service.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
awaitTermination aşağıdaki kodu aşağıdaki örnekte görüldüğü gibi çalışan tüm threadlere join yapılmasına benzer.


awaitTermination metodu shutDown metodu çağırılmadan kullanılmamalıdır çünkü bu metod çalışan thread sayısı gösteren bir AtomicInteger üzerinde for döngüsü içinde spin wait yapar.
Verilen sürede tüm işler bitirilmeyebilir. Herşeyin bitmesini beklemenin en iyi yolu döngü içinde beklemektir.
 while(!pool.isTerminated()){ //Tüm işlerin bitmesini bekle
    try {
     pool.awaitTermination(1000, TimeUnit.SECONDS);
     } catch (InterruptedException ex) {
        Logger.getLogger(ThreadManagement.class.getName()).log(Level.SEVERE,null, ex);
     }
}
İşleri teslim edip bitmesini beklemenin en güzel yolu invokeAll metodunu çağırmaktır.
Aşağıdaki örnekte CTRL+C tuşuna basılınca threadleri kapatmak kodu var.

Runtime.getRuntime().addShutdownHook(new Thread() {
    @Override
    public void run() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                //...
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
ThreadLocal
Thread'ler ile ilgili yazılarda bir de ThreadLocal sınıfına bakmakta fayda var.
Java Executors and per-thread (not per-work unit) objects? yazısından aldığım örnek aşağda.

Future.get
Future sınıfı ile thread'in sonucu alınmaya çalışılırken timeout değeri verilebilir. Eğer istenilen süre içinde cevap alınmazsa bile, çalışan thread iptal edilmiyor.

21 Kasım 2013 Perşembe

DateTime İşlemleri

Not: Bu yazı ile ilgili olarak Epoch ve API başlıklı yazıya göz atabilirsiniz.
Not2: Joda-Time başlıklı yazı mutlaka okunması gereken bir yazı


Jülyen
Jülyen takvimde bir şey yapıldığını hiç görmedim.
Joda
Jülyen tarih saat bilgisi için aşağıdaki kod kullanılabilir.

Hicri Takvim
Joda
Gregoryan ve Hicri takvim arasında dönüşüm için örnek burada.

Gregoryan Takvim
Anladığım kadarıyla Gregoryan takvim ile ISO takvim aynı şeyler.
Gregoryan Gün (Sadece Gün Bilgisi)

Gregoryan Gün Yaratma
Joda
LocalDate start = new LocalDate(2012, 05, 1);
Bu sınıf aynı boost eşleniği gibi sadece gün bilgisi içerir. Saat bilgisini içermez. Zaten yarım bilgi içerdiği için ReadablePartial arayüzünden türemiştir. Örneğin doğum günü bilgisini tutmak için kullanılabilir.How to convert an epoch date to joda times LocalDate?
sorusunda da açıklandığı gibi bu sınıfı ileri veya geri oynatabilme imkanı da mevcut.
Bir diğer önemli nokta ise bu sınıfa 1 Ocak 1970'ten önceki tarihlerin de atanabilmesi. Data type for storing a date prior to 1970-01-01 sorusuna aşağıdaki örnek verilmiş.


Boost
boost::gregorian::date sıfını sadece tarih bilgisini içerir. Saat bilgisini içermez.

bu sınıfın yıl bilgisine erişmek için year() metodu kullanılır. Örnek:


gregorian::date sınıfı bir string'de parse etme imkanı da var.
using namespace boost::gregorian;
string s("2012-01-12");
date d2 = from_string(s);
Bir başka örnek:
std::string s_date = "1922-02-29";
boost::gregorian::date d = boost::gregorian::from_date(s_date);
date_input_face ile parse etmek için örnek:

#include <iostream>
#include "boost/date_time/gregorian/gregorian.hpp"

int main(int argc, char *argv[])
{
  std::string s_date = "1922-02-28";
  std::stringstream ss(s_date);
  boost::gregorian::date_input_facet *df = new boost::gregorian::date_input_facet("%Y-%m-%d");
  ss.imbue(std::locale(ss.getloc(), df));
  date d;
  ss>>d;
  std::cout<<d<<std::endl;
}

gregorian::date sınıfını verilen tarih için yaratma imkanı da bulunmakta.
using namespace boost::gregorian;
date d(2002,Jan,10);
Eğer verilen tarih geçersiz ise std::out_of_range exception'ı atılır.

 boost::gregorian::date_period sınıfı iki date arasındaki zamanı temsil etmek için kullanılır. Aşağıdaki örnekte gösterildiği gibi iki gün arasındaki farkı bulmak için kullanılabilir.

date_period dp(date(2002,Jan,1),
               days(2));
dp.length() --> 2
QT

QT ile gelen QDate sınıfı Gregoryan gün işlemleri için kullanılabilir

Gregoryan Gün ve Saat Yaratma
Joda
LocalDateTime sınıfı ile saat dilimi bilgisi içermeyen bir nesne yaratılır.
   

Verilen İki Günü Karşılaştırma
Boost
İki günü karşılaştırmak için "<", ">" operatörleri kullanılabilir. Örnek
SQL
MySQL ile verilen bir güne ait kayıtları çekmek mümkün. Örnek'te DATE_ADD fonksiyonu yerine INTERVAL kullanılmış:

Yerel Saat (Sadece Saat)

Geceyarısından Beri Geçen Saniyeyi Zamana Çevirme
Joda
Bir başka örnek ise
LocalTime localTime = new LocalTime(13, 30, 26, 0);// 1:30:26PM

Eğer DateTime nesnesinin sadece saat kısmını almak istiyorsak DateTime.toLocalTime() metodu da kullanılabilir.

QT
QT ile gelen QTime sınıfı sadece saat işlemleri için kullanılabilir.


Geceyarısından Beri Geçen Milisaniyeyi Bulma
Joda
JodaTime Get Current Milliseconds From Beginning Of Day başlıklı soruda geceyarısından beri geçen milisaniyeyi hesaplamak için şöyle bir cevap var.


long result = new DateTime().millisOfDay().getMillis(); 

Tarih ve Saat İşlemleri

Belli Tarihi Atama
boost
ptime t4(date(2002,May,31), hours(20));  
Joda
Buradaki soruda DateTime sınıfının aşağıdaki constructor metodu kullanılarak belli bir tarih atanabileceği gösterilmiş. Eğer verilen tarih hatalı ise IllegalFieldValueException atılıyor.

DateTime dt = new DateTime(2012, 2, 12, 0, 0); // 12 Şubat 2012 gece yarısı
Bu soruda ise withDate ile belli bir tarih atanabileceği gösterilmiş.

Gece Yarısını Atama
Java
Calendar cal = Calendar.getInstance();
//şu anı al
cal.setTime(new Date());

// Set time fields to zero 
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
Joda
DateMidnight kullanılabilir.
DateMidnight midnight = DateMidnight.now ();
Aşağıdaki örneklerde gece yarısını bulmak için başka yöntemler de gösteriliyor.
DateTime d;//
d.toDateMidnight();//DateMidnight

d.withTimeAtStartOfDay();//DateTime

Verilen Tarihin Saat Başını Alma
boost
Örneği buradan aldım.
boost::posix_time::ptime now= boost::posix_time::second_clock::local_time();

year_ = now.date().year();
month_ = now.date().month();
day_ = now.date().day();
hours_= now.time_of_day().hours();
Java
Java: getMinutes and getHours başlıklı soruda açıklanıyor.

Joda

Joda ile getHourOfDay() metodu kullanılarak verilen DateTime sınıfının saat başı öğrenilebilir.
Verilen TarihinYılın Kaçıncı Haftası Olduğunu Alma
Joda
Joda getWeekYear() metodu kullanılarak verilen DateTime sınıfının yılın kaçıncı haftası olduğu öğrenilebilir. Representing week of year with jodatime sorusuna da bakılabilir.

calculate weeks for one month in jodatime sorusuna da bakılabilir.
Verilen Tarihin Haftanın Kaçıncı Günü Olduğunu Alma
Hafta günleri Pazar'dan ve 1 sayısından başla.
Java
Calendar sınıfının get(Calendar.DAY_OF_WEEK) metodu ile haftanın kaçıncı günü olduğu bulunabilir. Örnek'te Aralık 2012'de 5 tane Pazar, Pazartes, ve Cumartesi günü olduğu kontrol ediliyor
Joda
Joda getDayOfWeek() metoduyla bu yapılabilir.
1 <= time.getDayOfWeek() && time.getDayOfWeek() <= 5 //Pazartesi ve Cuma arasında
Eğer haftanın kaçın günü olduğunu metin olarak almak istersek aşağıdaki gibi yapabiliriz.


Verilen Tarihin 1,2,3,4. Pazar gününü bulma
Java
Joda Time: Get first/second/last sunday of month sorusunda Java ile örnek var.

Joda
Joda - How to find “Second Thursday of Month”  sorusunda yukarıdakine benzer bir örnek var. Her iki çözümde de önce withDayOfMonth() ile ay başına gidiliyor. Daha sonra ise withDayOfWeek ile istenilen gün atanıyor. 
int year = 2012;
int month = 1;
int day = 1;
LocalDate start = new LocalDate(year, month, day);
LocalDate date = start.withDayOfMonth(1).withDayOfWeek(4);
date = (date.isBefore(start)) ? date.plusWeeks(2) : date.plusWeeks(1);
Verilen Tarihi İleri Alma
Boost
Örneği buradan aldım.
using namespace boost::posix_time;
ptime start = second_clock::local_time();
ptime end = start + minutes(4)+seconds(2);
 
 
Java

Java'da tarih hesaplaması için her zaman Calendar arayüzü kullanılır. Calendar arayüzünü gerçekleştiriren takvim ise GregorianCalendar sınıfıdır.


Calendar calendar = new GregorianCalendar(); calendar.add(Calendar.DAY_OF_MONTH, 30);
Verilen tarihi ileri alırken, calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); şeklindeki kullanım tarihi bir sonraki pazar gününe ilerletmek zorunda değil!

C#
c#: whats the easiest way to subtract time? sorusundaki örnekte de açıklandığı gibi aşağıdaki şekilde yapılabilir.

Apache Commons

DateUtils sınıfı yukarıdaki Java ile yapılan işlemleri zaten yapan bir sınıf. addXXX() gibi metodları kullanması oldukça kolay.

Joda

Joda ile gelen DateTime sınıfı değiştirilemez ancak ekle çıkartma yapılarak yeni bir sınıf elde edilebiliyor.

DateTime d2 = new DateTime().plusDays(30);
Aşağıdaki örnekte DateTime sınıfının aynı String gibi değiştirilemez olduğu gösterilmiş.


Bir başka örnek ise saati ileri alırken dakikayı da atamak
 DateTime d2 = new DateTime().plusHours(1).withMinuteOfHour (0);//Saati ileri al,dakikayı ata
Joda ile gelen MutableDateTime sınıfı setter() metodlara sahip olduğu için değiştirilebiliyor.


Bir başka örnek:


Joda'nın aşağıdaki yapısını bilmek faydalı.



C
Bu dil ile tarih hesaplaması yapmak çok zor ancak Addition some interval to tm structs başlıklı yazıda struct tm veri yapısını ileri bir tarihe almak için standart matematik işlemleri ve mktime() metodunun kullanılması öneriliyor.
mktime() metodu tarih/saat normalizasyonu yaptığı için bu işlemin çalıştığı söyleniyor.


Verilen Tarihi Tatile Denk Gelmeyecek Şekilde İleri Alma
Bu da çözülmesi gıcık problemlerden birisi.
Joda
joda time - add weekdays to date sorusunda aşağıdaki çözüm önerilmiş
addDays(DateTime dateTime, int days) {
    for(int i=0;i<days;i++){
        dateTime.plusDays(1);
        if(dateTime.getDayOfWeek()==6)
            dateTime.plusDays(2); // if Saturday add 2 more days
    }
}
 
Verilen Tarihi Geri Alma
Boost

Java

Java'da tarih hesaplaması için her zaman Calendar arayüzü kullanılır. Calendar arayüzünü gerçekleştiriren takvim ise GregorianCalendar sınıfıdır.


Calendar calendar = new GregorianCalendar();

calendar.add(Calendar.DATE, -1);
Bir başka alternatif ise yaz saati uygulamasını dikkate almadan direkt milisaniyeleri çıkartmaktır.
Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);
Joda
LocalDate today = LocalDate.now();
LocalDate yesterday = today.minus(Period.days(1));

Eğer istenirse bir DateTime nesnesinden milisaniye de çıkarılabilir. Why does JodaTime's DateTime class have a minusMillis() method? sorusu minus(long) ile minusMillis(int) arasındaki farkı açıklıyor.

C#
DateTime.Now.AddMinutes (-1); veya DateTime.Now.AddSeconds (-6);
Buradaki örnekte geçen cuma ve ondan önceki 6 cuma daha bulunuyor.

SQL
Örnekte verilen tarihi geri alma gösteriliyor.
 
Verilen Tarihi İleri/Geri Alma ve Yaz/Kış Saati Açıklaması
Java
Bu konuyu açıklayan bir yazı da Java's java.util.Calendar başlıklı yazı da var.
Calendar ile tarihi ileri alırken Yaz/Kış saati değişimi de dikkate alınır. Örneğin 
cal.add( Calendar.DAY_OF_YEAR, 1 );
kodunda How to offset Date to adjust to DST in Java sorusunda açıklandığı gibi 24 saat değil hesaplama yapılarak gerekirse 23 saat eklenir.


Verilen İki Tarihi Karşılaştırma
Java
Date sınıfını compareTo metodu kullanılabilir. Örnek :

Joda
Joda ile saat dilimi değil "an" karşılaştırılır. Aşağıdaki örnekte aynı olan iki an saat dilimleri farklı olsa bile hep false dönerler.
DateTime estDT = new DateTime(DateTimeZone.forID("America/Puerto_Rico")).withMillisOfSecond(0);
DateTime londonDT = new DateTime(DateTimeZone.forID("Europe/London")).withMillisOfSecond(0);
System.out.println("Comparison " + londonDT.isBefore(estDT));//false
System.out.println("Comparison " + londonDT.isAfter(estDT)); //false



isAfter ile > kontrolü yapılıyor.

isBefore ile < kontrolü yapılıyor. 
<= kontrolü için !after kontrolü yapılmalı.


>= komtrolü için !before kontrolü yapılmalı.

>= ve <= içinse aşağıdaki gibi yapılabilir.
 
isBeforeNow örneğinde verilen tarihin şu andan önce olup olmadığı kontrol ediliyor
isAfterNow ile verilen tarihin şu andan sonra olup olmadığı kontrol ediliyor.

equals ile verilen iki tarihin aynı olup olmadığı kontrol ediliyor.
while (weekday.isBefore(end) || weekday.equals(end))
Periyod İle İşlemler (İki tarih arasındaki fark)
Bu kısım çok uzun olduğu için İki Tarih Arasındaki Fark başlıklı yazıya taşıdım.


Duration İşlemleri
Duration tanım olarak başlangıç ve bitişi olmayan süre anlamına geliyor. Yani elapsed time difference. 2 saat 3 dakika gibi. Aslında Türkçe'de "her 2 dakikalık periyotta bir" gibi bir cümle kurarsak mana olarak doğru ancak Joda dilinde Duration sınıfına denk geliyor.

Apache
DurationFormatUtils ile verilen süreyi String olarak formatlama imkanı var.
//Çıktı olarak 23546_15:26:40.000 verir
return DurationFormatUtils.formatDuration(2034430000000L,"dd_HH:mm:ss.SSS");
Joda Duration
Duration sınıfı da iki tarih arasındaki farkı bulmak için kullanılabilir. Yalnız bu sınıf sadece milisaniye cinsinden çalışıyor. How to compare Joda DateTime objects with acceptable offset (tolerance)? sorusunda iki Duration nesnesini karşılaştırma örneği verilmiş.
Bir başka örnekte ise iki tarih arasındaki farkın 30 dakikadan az olduğu kontrolü yapılmış.

Boost

Boost ile diğer zaman birimlerini de temsil etme imkanı var. Örneğin 10 mikrosaniyeyi temsil etmek için:
boost::posix_time::time_duration fractionalSeconds(0, 0, 0,10);
unix timestamp to boost::posix_time::ptime sorusuna göz atmak ta faydalı olabilir.
Interval İle İşlemler
Interval tanım olarak başlangıç ve bitiş zamanı belli olan aralık anlamına geliyor. Saat 8 ve 10 arası gibi.
Joda Interval
Interval yaratmak için örnek:
// Now
DateTime dt = new DateTime();

// Now plus three years and a half
DateTime plusDuration = dt.plus(new Duration(110376000000L));

// Define and calculate the interval of time
Interval interval = new Interval(dt.getMillis(), plusDuration.getMillis());
Interval'ı String'den parse etmek için örnek:

Burada Interval ile ISO 8601 stringi parse etme konusu açıklanmış.
 
TimeStamp'ten Çevirme

C++

Yeni C++ ile gelen duration sınıfı da bu iş için kullanılabilir.
typedef std::chrono::duration<double, std::ratio<1>> d_seconds;
d_seconds since_epoch_full(324324.342);
How to convert a fractional epoch timestamp (double) to an std::chrono::time_point? sorusuna göz atmak ta faydalı olabilir.
Joda
Converting Unix timestamp to String with Joda Time sorusunda da açıklandığı gibi Unix Timestamp değerleri saniye cinsinden tutuluyor. Eğer bunu Joda DateTime nesnesine çevirmek istiyorsak aşağıdaki gibi saniyeyi milisaniyeye çevirmemiz lazım.


Saat Dilimi ile Çalışma
Saat dilimlerinin listelenmesinde farklı veritabanları kullanılıyor. Bunlardan en popüler olanı tz database,
diğer ismiyle Olson database. Ancak her yazılım bu veritabanı ile uyumlu değil, örneğin Microsoft kendi veritabanını kullanıyor.
 
Saat dilimi ile çalışmaya başlamadan önce saat dilimi ile System.currentTimeMillis() metodu arasındaki ilişkiyi anlamak lazım.

Java
Saat dilimini temsil eden sınıf TimeZone. Türkiyedeki saat diliminin ismini almak için aşağıdaki kod kullanılabilir.

TimeZone.getDefault().getDisplayName(); // Eastern European Time verir
Bir başka örnekte ise default saat dilimini atama gösteriliyor.
TimeZone.setDefault(TimeZone.getTimeZone("Etc/UTC")); //veya
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
Aşağıdaki örneği buradan changeTimezone metodundan aldım. Verilen bir Timestamp nesnesini bir başka saat dilimine göre çeviriyor. Bu örneğin JDBC sunucusunda ne işe yaradığını bilmiyorum. Bence JDBC sunucusu bu çevirim işini yapmamalı.

TimeZone fromTz = //
TimeZone toTz = //
Timestamp tstamp = //

Calendar fromCal = Calendar.getInstance(fromTz);
fromCal.setTime(tstamp);

int fromOffset = fromCal.get(Calendar.ZONE_OFFSET)   + fromCal.get(Calendar.DST_OFFSET);
Calendar toCal = Calendar.getInstance(toTz);
toCal.setTime(tstamp);

int toOffset = toCal.get(Calendar.ZONE_OFFSET) + toCal.get(Calendar.DST_OFFSET);
int offsetDiff = toOffset - fromOffset;
long toTime = toCal.getTime().getTime();
toTime += offsetDiff;

Timestamp changedTimestamp = new Timestamp JavaDoc(toTime);

return changedTimestamp;

Aşağıdaki örnekte verilen string saat dilimine göre parse ediliyor.


 
TimeZone sınıfı ile saat diliminin kaç dakikalık farka sahip olduğunu hesaplama kodunu buradan aldım.

Timezone tz = TimeZone.getTimeZone("Europe/Oslo");
tz.getOffset(new Date().getTime()) / 1000 / 60;   //yields +120 minutes

Joda
Saat dilimini temsil etmek için DateTimeZone sınıfı kullanılıyor. Joda tarafından desteklenen saat dilimilerini burada bulabilirsiniz.

DateTimeZone.getDefault(); 
Bu sınıfı TimeZone sınıfını kullanarak yaratmak için aşağıdaki kod kullanılabilir.

TimeZone javaZone = TimeZone.getDefault();
DateTimeZone jodaTimezone = DateTimeZone.forTimeZone(javaZone);
Eğer verilen saat diliminin Joda tarafından tanınıp tanınmadığını bilmek istiyorsak aşağıdaki gibi yapabiliriz.
boolean valid = DateTimeZone.getAvailableIDs().contains(id);
UTC Saatini Yerel Saate Çevirme
boost
local_date_time sınıfı ile yapılıyor. Örnek:
 
Yerel Saati Bir Başka Saat Dilimindeki Zamana Çevirme

boost
Aşağıdaki örnekte yerel saat bir başka saat dilimine çeviriliyor. Çevrim için boost::date_time::local_adjustor sınıfına yerel saat diliminin GMT -5 olduğu söyleniyor.

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/local_time_adjustor.hpp>
#include <iostream>

using namespace boost::posix_time;
using namespace boost::date_time ;

int main (void) {
   ptime now = second_clock::local_time();
   ptime adjUSDST = local_adjustor<ptime, -5, us_dst>::utc_to_local(now);
   ptime adjNODST = local_adjustor<ptime, -5, no_dst>::utc_to_local(now);
   std::cout << "now: " << now << std::endl;
   std::cout << "adjUSDST: " << adjUSDST << std::endl;
   std::cout << "adjNODST: " << adjNODST << std::endl;
   return 0;
}
   Java
//Japonyadaki saate çevir
Calendar japanCal = Calendar.getInstance(TimeZone.getTimeZone("Japan"));
japanCal.setTimeInMillis(Calendar.
getInstance().getTimeInMillis());
Bir başka örnekte ise Calendar kullanmadan çevirme örneği var.
Date currentTime = new Date();
      
DateFormat ausFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
ausFormat.setTimeZone(TimeZone.getTimeZone("Australia/Melbourne"));

//get the time string in australian timezone
String ausTime  = ausFormat.format(currentTime);
Joda
Joda ile gelen DateTime sınıfı eğer yaratılırken bir saat dilimi atanarak yaratılmaz ise sistemin saat dilimini esas alır. JodaTime-Passing a string directly to DateTime's constructor sorusunda da açıklandığı gibi bu durumda verilen saatin başka bir saat dilimine ait olduğunu tesbit ederse verilen saat yerel saat dilimine uyacak şekilde ileriye veya geriye alarak değiştirir. Yani içinde tuttuğu milisaniye miktarını değiştirir. Dolayısıyla DateTime sınıfı her zaman saat diliminden haberdardır.

Yine buradaki soruda da withYear, withXXX() metodları ile verilen rakamları da milisaniyeye çevirirken ileri veya geri alabileceği anlatılmış.

Aşağıdaki test kodunda ZonedChronology sınıfının verilen değeri UTC olarak kabul ettiği ve yerel saate göre uyarladığı net bir şekilde görülebiliyor.


Joda Time - different between timezones sorusunda yerel saati bir başka saat dilimine çevirmek için withZone metodu kullanılmış.


Buradaki örnekte saati dilimi tutulsa bile verilen milisaniye değerinin hep aynı olduğu gösteriliyor.

 
Direkt olarak bir başka zaman dilimine ait saat yaratmak için ise DateTime(DateTimeZone zone) constructor kullanılabilir.


DateTimeZone sınıfını yaratmak için bir çok metod var. Bunlar forID(), forOffsetHours() gibi metodlar olabilir.

Bir başka örnekte ise DateTime(long instant, DateTimeZone zone) constructor kullanılıyor.
ya da bu örnekte olduğu gibi 

// (GMT -1) 23/10/2010 23:00:00 
DateTime dateTime = new DateTime(2010, 10, 23, 23, 0, 0, 0, DateTimeZone.forOffsetHours(-1));  DateTime inAnotheTimeZone = dateTime.withZone(DateTimeZone.forOffsetHours(1));

olabilir. Bu şekil kullanımda artık yeni nesnenin saati dilimi yaratılırken verildiği için saati ileri geri alma olmaz.
Yaz Saati Uygulaması
Joda
Her saat dilimi yaz saatini desteklemez. Örneğin GTM saat diliminde yaz saati uygulaması yoktur. Örnek:
TimeZone zone = TimeZone.getTimeZone("GMT");
zone.useDaylightTime();//false döner
Saat Dilimleri Arasındaki Süre Farkı
Boost
Örnekte UTC ile yerel saat arasındaki fark bulunmuş.

using namespace boost::posix_time;
using namespace boost::gregorian;

time_duration UTC_Diff;
{
    ptime someUTC_Time(date(2008, Jan, 1), time_duration(0, 0, 0, 0));
    ptime someLocalTime = boost::date_time::c_local_adjustor::utc_to_local(someUTC_Time);
    UTC_Diff = someLocalTime - someUTC_Time;
}
Buradaki örnekte ise UTC  ile yerel saat arasındaki fark bulunmuş ve +02:00 gibi string olarak gösterilmiş.

Buradaki örnekte benzer bir şekilde UTC ile yerel saat arasındaki fark bulunmuş.

c_local_adjustor sınıfının açıklması ise burada. UTC zamanı yerel zaman çeviriyor.
boost::date_time::c_local_adjustor uses the C-API to adjust a moment given in utc to the same moment in the local time zone. 
Joda
Buradaki örnekte saat dilimleri arasındaki süre farkını bulmak için aşağıdaki örnek verilmiş.
DateTime nowHere = DateTime.now();
DateTime nowZur = nowHere.withZone(DateTimeZone.forID("Europe/Zurich"));
Period per=new Period(nowHere.toLocalDateTime(),nowZur.toLocalDateTime());
System.out.println(per.toStandardSeconds().getSeconds());
------------------------------------YAZMA İŞLEMLERİ-------------------------------------------------
ISO 8601 formatında yazma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.


Belirsiz bir formatta yazma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.

-------------------------------------OKUMA İŞLEMLERİ-----------------------------------------------
ISO 8601 formatında okuma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.

Belirsiz bir formatta okuma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.
 
DateTimeFormat ve Thread Safety
Java
DateFormat ve SimpleDateFormat sınıfları thread-safe değil.Java'daki Date sınıfı saat dilimi ve gösterim bilgisini bilmez. Sadece Epoch'tan beri geçen süreyi tutan sabit bir sınıf gibi düşünülebilir. Bu durum anladığım kadarıyla C#'ta da aynı.

Joda
Joda ile parse ve print işlemleri için DatetimeFormat sınıfı kullanılıyor ve bu sınıf thread-safe
 
Karşılaştığım bazı zaman formatları
Bu konuyu not almak istedim çünkü envai çeşit zaman formatı var.

Gün/Saat ve Saat Dilimi alanı örnekleri

"2010-10-03T16:58:07.000+02:00" : Burada tek dikkat edilmesi gereken bu saatin yerel saati göstermesi ve gün/saat bilgisi arasındaki T harfi ve saat dilimi alanı. Bu bilgi yerel saatin 16:58:07 olduğunu milisaniyenin değerinin de 000 olduğunu ve yerel saatin GMT'den 2 saat önde olduğunu bildiriyor.

"Tue, 14 Aug 2012 07:26:33 +0000" : Bu saat yukarıdaki ile aynı bilgileri gösteriyor. Tek fark gün isminin de yazılı olması. Bu saati parse etmek için "EEE, dd MMM yyyy HH:mm:ss Z" formatı kullanılabilir. 

ISO 8601 ile duration P harfi ile başlar. Örneğin P10Y 10 sene anlamına gelmektedir.

Locale İşlemleri
Java
SimpleDateFormat(pattern,Locale) metodu kullanılarak farklı bir dilde formatlama yapmak mümkün. Örnek:

Sabit Değerler
Joda
Joda ile gelen DateTimeConstants sınıfı bir çok sabit değeri içeriyor.