public class ProjectDAO {

  private final Provider<EntityManager> entityManagerProvider;

  @Inject
  public ProjectDAO(Provider<EntityManager> entityManagerProvider) {

    this.entityManagerProvider = entityManagerProvider;
  }
}

@NamedQueries({
    @NamedQuery(name = "project.findAll", query = "from project"),
    @NamedQuery(name = "project.deleteByProjectName", query = "delete from project p where p.name = :project_name")
}
)
@Entity(name = "project")
public class Project {

    @Id
    @GeneratedValue
    private Long id;

    @Column(name="name")
    private String name;

    // ... getters/setters
}

public class ProjectDAO {

  private final Provider<EntityManager> entityManagerProvider;

  @Inject
  public ProjectDAO(Provider<EntityManager> entityManagerProvider) {
    this.entityManagerProvider = entityManagerProvider;
  }

  public void insert(Project project) {
    entityManagerProvider.get().persist(project);
  }

  public List<Project> findAll() {

    return entityManagerProvider.get()
        .createNamedQuery("project.findAll", Project.class)
        .getResultList();
  }

  public void delete(String projectName) {

    entityManagerProvider.get()
        .createNamedQuery("project.deleteByProjectName")
        .setParameter("project_name", projectName)
        .executeUpdate();
  }

  public Project findById(Long id) {

    return entityManagerProvider.get().find(Project.class, id);
  }
}

public class ProjectService {

  private final ProjectDAO projectDAO;

  @Inject
  public ProjectService(ProjectDAO projectDAO) {

    this.projectDAO = projectDAO;
  }

  @Transactional
  public void addProject(Project project) {
    projectDAO.insert(project);
  }

  @Transactional
  public List<Project> findAll() {
    return projectDAO.findAll();
  }

  @Transactional
  public void delete(String projectName) {
    projectDAO.delete(projectName);
  }

  @Transactional
  public Project findById(Long id) {
    return projectDAO.findById(id);
  }

  public EntityManager getEntityManager() {
    return projectDAO.getEntityManager();
  }
}

public class Start {

  public static void main(String[] args) throws InterruptedException {

    Injector injector = Guice.createInjector(new AbstractModule() {
      @Override
      protected void configure() {
        install(new JpaPersistModule("hibernatetesting"));
        bind(ProjectService.class).in(Scopes.SINGLETON);
      }
    });

    ProjectService projectService = injector.getInstance(ProjectService.class);
    PersistService persistService = injector.getInstance(PersistService.class);

    persistService.start();

    // For the purpose of making transactions from different threads, we
    // create two single threaded executors
    ExecutorService executorService1 = Executors.newSingleThreadExecutor();

    ExecutorService executorService2 = Executors.newSingleThreadExecutor();

    // Execute a few queries from Thread 1
    CountDownLatch countDownLatch1 = new CountDownLatch(1);

    executorService1.execute(() -> {
      projectService.addProject(new Project("project1"));
      projectService.addProject(new Project("project2"));
      countDownLatch1.countDown();
    });

    countDownLatch1.await();


    // Execute a few queries from Thread 2
    CountDownLatch countDownLatch2 = new CountDownLatch(1);

    executorService2.execute(() -> {
      projectService.addProject(new Project("project3"));
      projectService.addProject(new Project("project4"));

      //----
      projectService.delete("project1");
      //----

      // project3 is not shown in this list
      projectService.findAll().forEach(System.out::println);
      countDownLatch2.countDown();
    });

    countDownLatch2.await();

    // Execute a few more queries from Thread 1
    CountDownLatch countDownLatch3 = new CountDownLatch(1);

    executorService1.execute(() -> {
      projectService.addProject(new Project("project5"));
      projectService.addProject(new Project("project6"));

      // project3, which was deleted in Thread 2 is still visible in
      // this EntityManager
      // ----
      Project project = projectService.findById(3L);
      System.out.println("Project still exists " + project);
      // ----

      projectService.findAll().forEach(System.out::println);
      countDownLatch3.countDown();
    });

    countDownLatch3.await();

  }
}