Java ME'de Location API Kullanımı

Java deyince genellikle akla ilk olarak java programlama dili gelmektedir. Bu çok da yanlış sayılmaz. Ancak java öncelikli olarak bir platformun adıdır. Bu platform bize java programlama dilini kullanarak uygulama geliştirmek, geliştirdiğimiz bu uygulamayı dağıtmak ve en sonunda bu uygulamayı çalıştırmak için bir ortam sağlar. Üstelik bu platform tek de değildir. Java Standard Edition (SE), Java Enterprise Edition (EE), Java Micro Edition (ME), Gömülü Java, Java Card, JavaFx gibi biri biriyle ilintili ama farklı platformlar bulunmaktadır. Peki neden tek platform yeterli değildir? Sizce neden bunca sayıda platforma ihtiyaç duyulmuş olabilir? İşlevsel olmayan gereksinimleri ve doğal sonucu olarak mimarileri biri birinden farklı uygulama türleri bulunur: konsol uygulamaları, masa üstü uygulamaları, istemci-sunucu mimarisine sahip uygulamalar, çok katmanlı ve dağıtık uygulamalar. Java platformlarının her biri belirli bir tür uygulama türünde uygulama geliştirmek çin tasarlanmıştır. Örneğin, konsol ve masaüstü uygulamalar geliştirmek için Java SE, cep telefonu gibi kısıtlı bellek ve işlemci kapasitesine sahip cihazlar için ise Java ME platformu kullanılır. Konsol uygulamalarında kullanıcı etkileşimi tuş takımı ve ekran üzerinden gerçekleşmektedir. Uygulamanın çalışma sırası kod sırasını takip eder ve ardışıl bir akışa sahiptir. Masa üstü uygulamaları grafiksel kullanıcı arayüzüne sahiptir ve olay temelli olarak çalışır. Olay kullanıcının bir düğmeye basması, metin kutusuna bir değer girmesi gibi kullanıcı arayüzü ile yaptığı etkileşimleri modeller. Uygulama çalışmaya başlar başlamaz uykuya dalar ve bir olay gerçekleşmesi için bekler. Olay gerçekleştiğinde uyanır ve geliştirici tarafından bu olay için kaydedilen metodu çalıştırır. Bu çalışma biçimi başka benzer problemlerde de kullandığımız bir kalıptır ve gözlemci kalıbı olarak adlandırılır. Java platformları arasında en güçlü ve gelişmiş olanı Java EE platformudur. Java EE platformunu kullanarak kurumsal uygulamalar geliştirilir. Kurumsal uygulamaların masa üstü uygulamarından beklemediğimiz farklı iki işlevsel olmayan gereksinimi bulunur: Yüksek erişilebilirlik ve ölçeklenebilirlik. Uygulamayı oluşturan bileşenler birden fazla makinaya dağıtılmış olarak çalıştırılabilinir. Makinalardan biri donanımsal ya da yazılımsal bir problem nedeni ile erişilemez olduğunda geriye kalan makinalar kullanıcılardan gelen isteklere cevap vermeye devam edecektir. Diğer taraftan kullanıcı sayısı arttığında kümeye yeni makinalar ekleyerek artan ihtiyacı karşılamak mümkün olabilir.

Java platformları arasında en zayıf olanı Java ME'dir diyebiliriz. Java ME'nin yerini iPhone OS ve Android platformlarının aldığını söyleyebiliriz. Aslında Java ME bir platform iken Android ve iPhone OS ise birer işletim sistemidir. Dolayısı ile karşılıştırılmaları çok da doğru olmayacaktır. Oracle Sun'ı satın aldıktan sonra Java platformunun geleceği konusunda bazı şüpheler ve kaygılar ortaya çıkmış olsa da geçen 2-3 sene boyunca bu satın almanın en azından Java platformu için olumlu olduğunu genel olarak söyleyebiliriz. Oracle tekrar Java ME'ye yüklendiğini ve öne çıkarmaya çalıştığını gözlemliyoruz. Bu ne kadar anlamlı bir adım ya da Oracle bundan nasıl bir çıkar bekliyor, açıkçası kestiremiyorum. Bundan bağımsız olarak Java ME'de hala az da olsa uygulama geliştirildiğini görebiliyoruz. Android yada iPhone OS'e göre oldukça kısıtlı bir programlama yeteneği sunuyor. Burada Location API ile ilgili basit bir örnek kod göstermek istiyorum. Örnek kod cihazdan aldığı konum bilgilerini ekranda gösteriyor. Kodun çalışabilmesi için projeye Lightweight UI Toolkit 1.5 kütüphanesinin eklenmesi gerekir. Bu kütüphaneyi linki izleyerek indirebilirsiniz. Zip dosyayı açtığınızda lib dizininde bulunan LWUIT_MIDP.jar ve MIDP_IO.jar dosyalarını projeye eklemeniz yeterli olacaktır. SimpleLocationMidlet sınıfı MIDlet sınıfından türetilmiştir. Konum bilgilerini ise gözlemci kalıbını kullanarak öğreneceğiz. Bunun için SimpleLocationMidlet sınıfı LocationListener arayüzünü gerçekleyecek şekilde tanımlanmıştır. Bu arayüzün iki tane metodu bulunmaktadır: locationUpdated ve providerStateChanged. Konum bilgisi değiştiğinde locationUpdated metodu ve cihazın durum değişikliğinde ise providerStateChanged metodu tetiklenmektedir. Konum bilgisi cihaz tarafından sağlanmaktadır. Cihazın bu yeteneği LocationProvider sınıfı ile modellenmektedir. LocationProvider ile gözlemci arasındaki ilişki kodda aşağıdaki gibi sağlanmaktadır:

       LocationProvider lp = LocationProvider.getInstance(null);
       lp.setLocationListener(this, 2, 1, -1);

Kodu test etmek için Java ME SDK 3.2 ile birlikte gelen emülatör kullanılabilir. Konum bilgisi değişikliğini simğle etmek için aşağıdaki gibi basit bir betik yazmak ve çalıştırmak gerekir:

   <waypoints>
      <waypoint time="0" latitude="0" longtitude="5" altitude="0"/>
      <waypoint time="15000" latitude="30" longtitude="10" altitude="50"/>
   </waypoints>

package com.example;

import com.sun.lwuit.Display;
import com.sun.lwuit.Form;
import com.sun.lwuit.Label;
import com.sun.lwuit.layouts.BoxLayout;
import javax.microedition.location.Location;
import javax.microedition.location.LocationException;
import javax.microedition.location.LocationListener;
import javax.microedition.location.LocationProvider;
import javax.microedition.location.QualifiedCoordinates;
import javax.microedition.midlet.*;

public class SimpleLocationMidlet extends MIDlet implements LocationListener {

    private Label lonLabel, latLabel, altLabel, stateLabel;

    public void startApp() {
        Display.init(this);
        stateLabel = new Label();
        latLabel = new Label("Lat: ");
        lonLabel = new Label("Lon: ");
        altLabel = new Label("Alt: ");
        try {
            LocationProvider lp = LocationProvider.getInstance(null);
            lp.setLocationListener(this, 2, 1, -1);
            setStateString(lp);
        } catch (LocationException ex) {
            stateLabel.setText(ex.getMessage());
        }
        Form form = new Form("Location");
        form.setLayout(new BoxLayout(BoxLayout.Y_AXIS));
        form.addComponent(stateLabel);
        form.addComponent(latLabel);
        form.addComponent(lonLabel);
        form.addComponent(altLabel);
        form.show();
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void locationUpdated(LocationProvider lp, Location location) {
        if (location!= null) {
            QualifiedCoordinates coordinates = location.getQualifiedCoordinates();
            if (coordinates != null) {
                latLabel.setText("Lat: " + coordinates.getLatitude());
                lonLabel.setText("Lon: " + coordinates.getLongitude());
                altLabel.setText("Alt: " + coordinates.getAltitude());
            }
        }
    }

    public void providerStateChanged(LocationProvider lp, int i) {
        setStateString(lp);
    }

1.     private void setStateString(LocationProvider lp) {

        String state = "";
        if (lp.getState() == LocationProvider.AVAILABLE) {
            state += "Available";
        } else if (lp.getState() == LocationProvider.TEMPORARILY_UNAVAILABLE) {
            state += "Temporarily Unavailable";
        } else if (lp.getState() == LocationProvider.OUT_OF_SERVICE) {
            state += "Out of servive!";
        }
        stateLabel.setText(state);
    }
}

Uygulamanın kaynak koduna NetBeans projesi olarak bu bağlantıdan erişebilirsiniz. Aynı projeyi eclipse projesi olarak bu bağlantıdan indirebilirsiniz. Bunun için öncelikli olarak bu bağlantıdan Eclipse eklentisini kullanıdığınız Eclipse IDE'sine tanıtmanız ve makinanıza Java Me SDK 3.2 kurmanız gerekir. Eclipse for Mobile kurulumu için aşağıdaki adımları takip etmeniz uygun olur:

1.  Eclipse for Mobile'ı http://www.eclipse.org/downloads/packages/eclipse-mobile-developers/junosr2 indirin.
2. Help->Install New Software...
   
3. Add butonuna basın
   
4. Location etiketli alana "http://download.eclipse.org/releases/indigo" adresini girin:
   
5. Ok butonuna basın.
6. Mobile and Device Development Tools altındaki "Mobile Tools for Java Examples", "Mobile Tools for Java SDK" ve "Mobile Tools for Java Examples" liste başlıklarını seçiniz:   
7. Next butonuna basınız ve kurulumu tamamlayınız. Kurulum bitince Eclipse yeniden başlatmayı önerecektir. Kabul edin.
8. Eclipse yeniden açıldıktan sonra nihayet Oracle'ın sayfasından indirdiğimiz Java Me eklentisini  kurabiliriz.
9. Help->Install New Software...
10. Add butonuna basınız
11. Archive butonuna basınız ve eclipse-me-sdk-plugins-uc.zip dosyasını seçin.
12. Kurulumu tamamladıktan sonra jar çakıştırmasını gidermek için plugins dizini altındaki org.eclipse.jetty.server_8.1.3.v20120522.jar isimli dosyayı org.eclipse.jetty.server_8.1.3.v20120522.old olarak değiştiriniz.
13. Eclipse'i yeniden başlatın. Açıldığında artık Perspective listesinde Java Me gözükecektir:
    
    
14. Menüden Window->Preference'ı seçin.
15. Java ME->Device Management'ı seçin:
    
    

Manual Install butonuna tıklayın ve Java Me Platform SDK'nın kurulu olduğu dizini gösterin:

Aynı uygulamayı eclipse projesi olarak bu bağlantıdan indirebilirsiniz.

The easiest way to retrieve data from a database and present them to web users on Java EE Platform

If your aim is to just retrieve information from a database and then present them to a web user on Java EE platform, probably the easiest way is to use Java Server Pages (JSP) and JSP Standard Tag Library (JSTL) technologies. JSP is a web component model. It heavily uses  HTML, CSS, Javascript technologies to present the model to the web user. JSP is a presentation technology. In design time it is basically an HTML file. Though you can insert any java scriptlet. All JSP components are translated in run-time to a Servlet class and then the translated java codes are compiled into bytecodes by the web container . This process is done when the JSP page is requested for the first time. It is possible to tell the web container to do the translation and compilation during the deployment in order to enhance the response time . JSPs and Servlets are different components in design-time, the same component in run-time. JSP pages are dynamic while Servlets are static components. Whenever you make a change in JSP page, the web container detects the change and re-translate and re-compile the page into bytecode ready to be run on JVM.   

MVC is an architectural design pattern used in both desktop and web applications. Due to its distributed nature, implementation of MVC pattern in web applications is somewhat different from the one used in desktop applications. For example any model update does not directly reflect to the web page in the client machine. It requires a request-response cycle. So observer pattern is not used in traditional web applications. Observer pattern in web applications is usually implemented by employing Ajax-push technology or by using Web sockets of HTML 5. Model in MVC is implemented by JavaBeans component model.

The JavaServer Pages Standard Tag Library (JSTL) is a collection of useful JSP tags which encapsulates core functionality common to many JSP applications. One of these functionalities is found in sql tag library: 
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>     
In order to use this tag library, first you must define a a data source (connection pool). In our example, we use MySQL database server: 
<sql:setDataSource driver="com.mysql.jdbc.Driver"
                   url="jdbc:mysql://localhost:3306/world"
                   user="root" password="root"/>
Using a connection from the connection pool, we can send a valid SQL statement to the server:
<sql:query var="continents">
   SELECT DISTINCT CONTINENT FROM COUNTRY
</sql:query>
The result set is stored in the variable continents.  Another example is given below:
<c:if test="${not empty param.continent}">
   <sql:query var="countries">
     SELECT * FROM COUNTRY WHERE continent= '${param.continent}'
   </sql:query>
</c:if>
where the result set stored in the variable countries contains countries in the selected continent ${param.continent}.
In the sample application we ask for a continent from the user. User selects the continent and then press the List button. The page displays the countries in the selected continent.  The complete solution is given in the following Jsp code, index.jsp:   

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<sql:setDataSource driver="com.mysql.jdbc.Driver"
                   url="jdbc:mysql://localhost:3306/world"
                   user="root"
                   password="root"/>
<sql:query var="continents">
    SELECT DISTINCT CONTINENT FROM COUNTRY
</sql:query>
<c:if test="${not empty param.continent}">
    <sql:query var="countries">
        SELECT * FROM COUNTRY WHERE continent= '${param.continent}'
    </sql:query>  
</c:if>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>World Countries</title>
        <script type="text/javascript" src="js/jquery-1.8.3.min.js"></script>
        <style>
            tr.zebraHover { background-color: #FFFACD; }
            tr.striped_even { background-color:  #EFEFEF}
            tr.striped_odd { background-color:  #DFDFDF}            
        </style>
        <script type="text/javascript">
            $(document).ready(
            function () {
                $('tbody tr:even').mouseover(function(){
                    $(this).addClass('zebraHover');
                    $(this).removeClass('striped_even');
                });
                $('tbody tr:even').mouseout(function(){
                    $(this).removeClass('zebraHover');
                    $(this).addClass('striped_even');
                });
                $('tbody tr:odd').mouseover(function(){
                    $(this).addClass('zebraHover');
                    $(this).removeClass('striped_odd');
                });
                $('tbody tr:odd').mouseout(function(){
                    $(this).removeClass('zebraHover');
                    $(this).addClass('striped_odd');
                });
                $('tbody tr:odd').addClass('striped_odd');
                $('tbody tr:even').addClass('striped_even');
            }
            );
        </script>
    </head>
    <body>
        <form action="index.jsp" method="POST">
            <select name="continent">
                <c:forEach items="${continents.rows}" var="row">
                    <option value="${row.continent}">${row.continent}</option>
                </c:forEach>
            </select>
            <input type="submit" value="List"/>
            <br/>
            <c:if test="${not empty countries}">
                <table border="0">
                    <thead>
                    <tr>
                        <c:forEach items="${countries.columnNames}" var="headerName">
                            <th>${headerName}</th>
                        </c:forEach> 
                    </tr>
                    </thead>
                    <tbody>
                        <c:forEach items="${countries.rows}" var="row">
                            <tr>
                                <c:forEach items="${countries.columnNames}" var="columnName">
                                    <td>${row[columnName]}</td>
                                </c:forEach>
                            </tr>
                        </c:forEach>
                    </tbody>
                </table>    
            </c:if> 
        </form>
    </body>
</html>

The solution contains jQuery to add zebra effect to the table. You can download jQuery from http://www.jquery.com. Sample screen shots are given below:

You can download world database following the link. You can read the pdf to learn how to install MySQL and the world database. Changing this solution to Ajax-based application is simple. First we partition index.jsp into search.jsp and countries.jsp. Second, we add jquery code which sends the request asynchronously and makes partial update when the response is received:

 $('#listButton').click(function(){

     var continent= $('#selectContinent').val();

     $.ajax({

         method: "GET",

         url: "countries.jsp",

         data: "continent="+continent,

         success: function(responseData){

             $('#result').fadeOut('fast');

             $('#result').html(responseData).fadeIn('slow');

         }   

     });

  });

countries.jsp sends only the table containing the countries in the selected continent.

search.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<sql:setDataSource driver="com.mysql.jdbc.Driver"
                   url="jdbc:mysql://localhost:3306/world"
                   user="root"
                   password="root"/>
<sql:query var="continents">
    SELECT DISTINCT CONTINENT FROM COUNTRY
</sql:query>

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>World Countries</title>
        <script type="text/javascript" src="js/jquery-1.8.3.min.js"></script>
        <style>
            tr.zebraHover { background-color: #FFFACD; }
            tr.striped_even { background-color:  #EFEFEF}
            tr.striped_odd { background-color:  #DFDFDF}            
        </style>
        <script type="text/javascript">
            $(document).ready(
            function () {
                $('tbody tr:even').mouseover(function(){
                    $(this).addClass('zebraHover');
                    $(this).removeClass('striped_even');
                });
                $('tbody tr:even').mouseout(function(){
                    $(this).removeClass('zebraHover');
                    $(this).addClass('striped_even');
                });
                $('tbody tr:odd').mouseover(function(){
                    $(this).addClass('zebraHover');
                    $(this).removeClass('striped_odd');
                });
                $('tbody tr:odd').mouseout(function(){
                    $(this).removeClass('zebraHover');
                    $(this).addClass('striped_odd');
                });
                $('tbody tr:odd').addClass('striped_odd');
                $('#result table tbody tr:even').addClass('striped_even');
                $('#listButton').click(function(){
                    var continent= $('#selectContinent').val();
                    $.ajax({
                        method: "GET",
                        url: "countries.jsp",
                        data: "continent="+continent,
                        success: function(responseData){
                            $('#result').fadeOut('fast');
                            $('#result').html(responseData).fadeIn('slow');
                        }   
                    });
                });
            }
        );
        </script>
    </head>
    <body>
        <select id="selectContinent" name="continent">
            <c:forEach items="${continents.rows}" var="row">
                <option value="${row.continent}">${row.continent}</option>
            </c:forEach>
        </select>
        <input id="listButton" type="submit" value="List"/>
        <div id="result">

        </div>
    </body>
</html>

countries.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>

<sql:setDataSource driver="com.mysql.jdbc.Driver"

                   url="jdbc:mysql://localhost:3306/world"

                   user="root"

                   password="root"/>

<c:if test="${not empty param.continent}">

    <sql:query var="countries">

        SELECT * FROM COUNTRY WHERE continent= '${param.continent}'

    </sql:query>  

</c:if>

<c:if test="${not empty countries}">

    <table border="0">

        <thead>

            <tr>

        <c:forEach items="${countries.columnNames}" var="headerName">

            <th>${headerName}</th>

        </c:forEach> 

        </tr>

        </thead>

        <tbody>

        <c:forEach items="${countries.rows}" var="row">

            <tr>

            <c:forEach items="${countries.columnNames}" var="columnName">

                <td>${row[columnName]}</td>

            </c:forEach>

            </tr>

        </c:forEach>

        </tbody>

    </table>    

</c:if> 

How to change processor affinity in Windows and Linux

We have been playing multiple core processor systems for a long time. It is good to know that there are several cores available to run so many processes and threads in your system. The operating system is responsible how the processes are assigned to the cores. Usually you do not care how this process works. Actually modern operating system kernels are really successful to evenly distribute the load among the cores and can sometimes even migrate a thread or a process from one core to another if it is required. But sometimes you need to control or restrict the threads of a process to a subset of the cores. In Windows operating system you can easily restrict the threads to run on specific CPU's by using start command available since Windows XP.

Let's take a look at the start command line parameters:

s>start /?
Starts a separate window to run a specified program or command.

START ["title"] [/D path] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
      [/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
      [/NODE <NUMA node>] [/AFFINITY <hex affinity mask>] [/WAIT] [/B]
      [command/program] [parameters]

    "title"     Title to display in window title bar.
    path        Starting directory.
    B           Start application without creating a new window. The
                application has ^C handling ignored. Unless the application
                enables ^C processing, ^Break is the only way to interrupt
                the application.
    I           The new environment will be the original environment passed
                to the cmd.exe and not the current environment.
    MIN         Start window minimized.
    MAX         Start window maximized.
    SEPARATE    Start 16-bit Windows program in separate memory space.
    SHARED      Start 16-bit Windows program in shared memory space.
    LOW         Start application in the IDLE priority class.
    NORMAL      Start application in the NORMAL priority class.
    HIGH        Start application in the HIGH priority class.
    REALTIME    Start application in the REALTIME priority class.

    ABOVENORMAL Start application in the ABOVENORMAL priority class.

    BELOWNORMAL Start application in the BELOWNORMAL priority class.

    NODE        Specifies the preferred Non-Uniform Memory Architecture (NUMA)

                node as a decimal integer.

    AFFINITY    Specifies the processor affinity mask as a hexadecimal number.

                The process is restricted to running on these processors.

                The affinity mask is interpreted differently when /AFFINITY and

                /NODE are combined.  Specify the affinity mask as if the NUMA

                node's processor mask is right shifted to begin at bit zero.

                The process is restricted to running on those processors in

                common between the specified affinity mask and the NUMA node.

                If no processors are in common, the process is restricted to

                running on the specified NUMA node.

    WAIT        Start application and wait for it to terminate.

    command/program

                If it is an internal cmd command or a batch file then

                the command processor is run with the /K switch to cmd.exe.

                This means that the window will remain after the command

                has been run.

                If it is not an internal cmd command or batch file then

                it is a program and will run as either a windowed application

                or a console application.

    parameters  These are the parameters passed to the command/program.

NOTE: The SEPARATE and SHARED options are not supported on 64-bit platforms.

Specifying /NODE allows processes to be created in a way that leverages memory

locality on NUMA systems.  For example, two processes that communicate with

each other heavily through shared memory can be created to share the same

preferred NUMA node in order to minimize memory latencies.  They allocate

memory from the same NUMA node when possible, and they are free to run on

processors outside the specified node.

    start /NODE 1 application1.exe

    start /NODE 1 application2.exe

These two processes can be further constrained to run on specific processors

within the same NUMA node.  In the following example, application1 runs on the

low-order two processors of the node, while application2 runs on the next two

processors of the node.  This example assumes the specified node has at least

four logical processors.  Note that the node number can be changed to any valid

node number for that computer without having to change the affinity mask.

    start /NODE 1 /AFFINITY 0x3 application1.exe
    start /NODE 1 /AFFINITY 0xc application2.exe

If Command Extensions are enabled, external command invocation

through the command line or the START command changes as follows:

non-executable files may be invoked through their file association just

    by typing the name of the file as a command.  (e.g.  WORD.DOC would

    launch the application associated with the .DOC file extension).

    See the ASSOC and FTYPE commands for how to create these

    associations from within a command script.

When executing an application that is a 32-bit GUI application, CMD.EXE

    does not wait for the application to terminate before returning to

    the command prompt.  This new behavior does NOT occur if executing

    within a command script.

When executing a command line whose first token is the string "CMD "

    without an extension or path qualifier, then "CMD" is replaced with

    the value of the COMSPEC variable.  This prevents picking up CMD.EXE

    from the current directory.

When executing a command line whose first token does NOT contain an

    extension, then CMD.EXE uses the value of the PATHEXT

    environment variable to determine which extensions to look for

    and in what order.  The default value for the PATHEXT variable

    is:

        .COM;.EXE;.BAT;.CMD

    Notice the syntax is the same as the PATH variable, with

    semicolons separating the different elements.

When searching for an executable, if there is no match on any extension, then looks to see if the name matches a directory name.  If it does, the START command launches the Explorer on that path.  If done from the command line, it is the equivalent to doing a CD /D to that path.

The option affinity is the one we are interested in.  This option takes one parameter which instructs the process scheduler that the process threads run only on the selected subset of the cores. The parameter is an integer given in base 16. For 2-core hyper-thread cpu, operating systems senses 4 logical CPU's and let's denote them as CPU0, CPU1, CPU2 and CPU3. In the table given below, you can easily follow how the parameter controls which cores are used:

Parameter	CPU3	CPU2	CPU1	CPU0
0x01	-	-	-	+
0x02	-	-	+	-
0x03	-	-	+	+
0x04	-	+	-	-
0x05	-	+	-	+
0x06	-	+	+	-
0x07	-	+	+	+
0x08	+	-	-	-
0x09	+	-	-	+
0x0A	+	-	+	-
0x0B	+	-	+	+
0x0C	+	+	-	-
0x0D	+	+	-	+
0x0E	+	+	+	-
0x0F	+	+	+	+

where + means the corresponding CPU is used, and - means the corresponding CPU is NOT used in the scheduling. To verify that the start command with its options is working properly, i have written the following very simple java code:


package com.example.console;

public class TestCpuAffinity {
    public static void main(String[] args) {
    System.err.println("Number of available processor: "+Runtime.getRuntime().availableProcessors()); 
    }
}


The code simply prints the number of cores available out to the console. Here are the results:

start /affinity 0xF "running" /B java com.example.console.TestCpuAffinity
Number of available processors: 4

start /affinity 0xA "running" /B java com.example.console.TestCpuAffinity
Number of available processors: 2

start /affinity 0x1 "running" /B java com.example.console.TestCpuAffinity
Number of available processors: 1

start /affinity 0x2 "running" /B java com.example.console.TestCpuAffinity
Number of available processors: 1

start /affinity 0x3 "running" /B java com.example.console.TestCpuAffinity
Number of available processors: 2

It is easy to do the same thing in Linux with the help of taskset command which is basically use the same mask defined in Windows. The manual page of taskset is given below:


TASKSET(1)                    Linux User’s Manual                   TASKSET(1)

NAME
       taskset - retrieve or set a process’s CPU affinity

SYNOPSIS
       taskset [options] mask command [arg]...
       taskset [options] -p [mask] pid

DESCRIPTION
       taskset  is  used  to  set  or retrieve the CPU affinity of a running process given its PID or to launch a new COMMAND with a given CPU affinity.  CPU affinity is a scheduler property that "bonds" a process to a given set of CPUs on the system.  The Linux scheduler  will honor  the  given CPU affinity and the process will not run on any other CPUs.  Note that the Linux scheduler also supports natural CPU affinity: the scheduler attempts to keep processes on the same CPU as long as practical for performance reasons.  Therefore, forcing  a specific CPU affinity is useful only in certain applications.

       The  CPU  affinity  is represented as a bitmask, with the lowest order bit corresponding to the first logical CPU and the highest order bit corresponding to the last logical CPU.  Not all CPUs may exist on a given system but a mask may specify more CPUs than are present.
       A  retrieved  mask will reflect only the bits that correspond to CPUs physically on the system.  If an invalid mask is given (i.e., one that corresponds to no valid CPUs on the current system) an error is returned.  The masks are  typically  given  in  hexadecimal. For example,

       0x00000001
              is processor #0

       0x00000003
              is processors #0 and #1

       0xFFFFFFFF
              is all processors (#0 through #31)

       When taskset returns, it is guaranteed that the given program has been scheduled to a legal CPU.

OPTIONS
       -p, --pid
              operate on an existing PID and not launch a new task

       -c, --cpu-list
              specify  a  numerical  list  of  processors  instead of a bitmask.  The list may contain multiple items, separated by comma, and
              ranges.  For example, 0,5,7,9-11.

       -h, --help
              display usage information and exit

       -V, --version
              output version information and exit

USAGE
       The default behavior is to run a new command with a given affinity mask:
              taskset mask command [arguments]

       You can also retrieve the CPU affinity of an existing task:
              taskset -p pid

       Or set it:
              taskset -p mask pid

Here is the sample usage of taskset command on running firefox:

[root@server1 ~]# taskset -c 1 firefox &
[1] 1032

[root@server1 ~]# taskset -p 1032
pid 1032's current affinity mask: 2